Ruby4Skype 0.2.3 → 0.3.1

data/lib/skypeapi/os/mac.rb

@@ -1,10 +1,98 @@
+require 'osx/cocoa'
+OSX.require_framework 'Skype'
+
 module SkypeAPI
   module OS
     class Mac
-      #sorry...
-      def initialize
-        raise SkypeAPIError::NotImplement
+      class Server < OSX::NSObject
+        def clientApplicationName
+          @client_application_name
+        end
+        
+        addRubyMethod_withType 'skypeAttachResponse:', 'v@:i'
+        def skypeAttachResponse status
+          p [:skypeAttachResponse,status]
+          case status
+          when 0 #?
+          when 1 #sccess
+            @upper.attached = true
+          when 2 ####
+          end
+        end
+        
+        #addRubyMethod_withType 'skypeBecameAviable:', 'v@:@'
+        def skypeBecameAvilable notification
+          p [:skypeBecameAvilable,notification]
+        end
+        
+        #addRubyMethod_withType 'skypeBecameUnavialbe:', 'v@:@'
+        def skypeBecameUnavilable notification
+          p [:skypeBecameUnavilable,notification]
+        end
+        
+        #addRubyMethod_withType 'skypeAttachResponse:', 'v@:@'
+        def skypeNotificationReceived notifation_string
+          p [:skypeNotificationReceived,notifation_string]
+        end
       end
+      
+      def initialize client_application_name='ruby4skype'
+        raise Skype::Error::NotImplement
+        
+        @server = Server.alloc.init
+        @server.instance_variable_set :@upper, self
+        @server.instance_variable_set :@client_application_name, @client_application_name
+        OSX::SkypeAPI.setSkypeDelegate @server
+        
+        @notify = Hash.new
+        @event = Hash.new do |h,k|
+          h[k] = Array.new
+        end
+        
+        @attached = false
+        Thread.new do
+          OSX::NSRunLoop.currentRunLoop.run
+        end
+      end
+      
+      attr_reader :attached
+      
+      def attach
+        OSX::SkypeAPI.connect
+      end
+      
+      def attach_wait
+        self.attach
+        loop do
+          break if @attached
+          sleep 0.123
+        end
+      end
+      
+      def dettach
+        OSX::SkypeAPI.disconnect
+      end
+      
+      def skype_runnging?
+        OSX::SkypeAPI.isSkypeRunnging
+      end
+      
+      def invoke_prototype cmd
+        res = OSX::SkypeAPI.sendSkypeCommand(cmd)
+        @queue.push(proc{do_event(:sent, cmd)}) if exist_event? :sent
+        @queue.push(proc{do_event(:received, res)}) if exist_event? :received
+        return res
+      end
+      
+      def invoke_callback cmd,cb=Proc.new
+        res = invoke_prototype cmd
+        cb.call res
+      end
+      
+      def invoke_block cmd, waitLimit = WAIT_CMD_LIMIT
+        res = invoke_prototype cmd
+      end
+      
     end
   end
-end
+end

data/lib/skypeapi/os/notifier.rb

@@ -0,0 +1,31 @@
+module SkypeAPI
+  module OS
+    class Notifier
+      def notify
+        @notify ||= Hash.new
+      end
+
+      def add reg, block=Proc.new
+        notify[reg] = block
+      end
+
+      def del reg
+        notify.delete reg
+      end
+
+      def fire res
+        objects_notify_fire = false
+        notify.each do |reg, action|
+          if res =~ reg
+            action.call($1)
+            objects_notify_fire = true
+          end
+        end
+
+        unless objects_notify_fire
+          notify[nil].call(res) if notify[nil]
+        end
+      end
+    end
+  end
+end

data/lib/skypeapi/os/window_event_queue.rb

@@ -0,0 +1,198 @@
+require 'thread'
+
+class BlockQueue < Queue #:nodoc: all
+  def push_block block=Proc.new
+    push block
+  end
+end
+
+module SkypeAPI
+  module OS
+    class WindowsEventQueue
+      def initialize windows
+        @windows = windows
+        @pause_count = 0
+        @pause_mutex = Mutex.new
+      end
+
+      attr_reader :windows
+
+      def queue
+        @queue ||= BlockQueue.new
+      end
+
+      def length
+        @queue.length
+      end
+
+      def received_count
+        @received_count ||= 0
+      end
+      attr_writer :received_count
+      private :received_count=
+
+      def callback
+        @callback ||= Hash.new
+      end
+
+      def set_notify_selector block=Proc.new
+        @notify_selector = block
+      end
+
+      attr_reader :notify_selector
+
+      def hook
+        @hook ||= Hash.new do |h,k|
+          h[k] = Array.new
+        end
+      end
+
+      private :queue, :hook, :windows
+
+      def add_hook sym, block=Proc.new
+        hook[sym].push block
+      end
+
+      def del_hook sym, block=nil
+        unless block
+          hook[sym] = Array.new
+        else
+          hook[sym].delete block
+        end
+      end
+
+      def exist_hook? sym
+        if hook[sym].length > 0
+          return true
+        else
+          return false
+        end
+      end
+
+      def get_hook sym
+        hook[sym] ? true : false
+      end
+
+      def push response
+        self.received_count += 1
+        response = response.chop
+        push_received_hook(response)
+
+        cmd_num, res = response_match(response)
+        if cmd_num
+          @windows.wmHandler.del_send_buffer cmd_num.to_i
+          set_cmd_response(cmd_num, res)
+        else
+          when_detached if response_detached?(res)
+          push_notify res
+        end
+      end
+
+      def push_hook sym, *args
+        queue.push_block{ call_hook(sym, *args) }
+      end
+
+      def push_block block=Proc.new
+        queue.push block
+      end
+
+      def start_messageloop
+        @messageloop_thread = Thread.new{messageloop}
+      end
+
+      def messageloop
+        @messageloop_flag = true
+        while callback = queue.shift
+          sleep 0.001 while paused?
+          break if callback == :exit
+          callback.call
+        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
+      end
+
+      def close
+        queue.clear
+        queue.push :exit
+      end
+
+      def paused?
+        @pause_count > 0
+      end
+
+      def pause &block
+        if block
+          _pause
+          block.call
+          play
+        else
+          _pause
+        end
+      end
+
+      def _pause
+        @pause_mutex.synchronized{@pause_count += 1}
+      end
+
+      def paly
+        @pause_mutex.synchronized{@pause_count -=1}
+      end
+
+      def push_detached_hook
+        #windows.attached = false
+        queue.push_block{ call_hook(:detached) }
+        #SkypeAPI.attach
+      end
+
+      private
+
+      def push_received_hook(response)
+        queue.push_block{ call_hook(:received, response) }
+      end
+
+      def response_match(res)
+        res =~ /^(#(\d+?) )?(.+?)$/m
+        return [$2, $3]
+      end
+
+      def when_detached
+        windows.attached = false
+        queue.push_block{ call_hook(:detached) }
+        SkypeAPI.attach
+      end
+
+      def set_cmd_response(cmd_num, res)
+        cmd_num = cmd_num.to_i
+        if callback[cmd_num]
+          cb = callback[cmd_num]
+          callback.delete(cmd_num)
+          #@windows.invoke_callback_mutex.synchronize do
+            cb.call(res)
+            @windows.cv.broadcast
+          #end
+        end
+      end
+
+      def response_detached? res
+        res == 'CONNSTATUS LOGGEDOUT'
+      end
+
+      def push_notify res
+        queue.push_block{notify_selector.call res} if notify_selector
+      end
+
+      def call_hook sym, *args
+        hook[sym].each{ |h| h.call *args }
+      end
+
+    end
+  end
+end

data/lib/skypeapi/os/window_messagehandler.rb

@@ -0,0 +1,120 @@
+module SkypeAPI
+  module OS
+    class MessageHandler < SWin::Window
+
+      def init skypeAPI, queue
+        @skypeAPI = skypeAPI
+        @queue = queue
+
+        @dwDiscoverMsg = RegisterWindowMessage.call("SkypeControlAPIDiscover");
+        raise SkypeAPI::Error::Attach.new("SkypeControlAPIDiscover nothing") unless @dwDiscoverMsg
+
+        @dwAttachMsg = RegisterWindowMessage.call("SkypeControlAPIAttach")
+        raise SkypeAPI::Error::Attach.new("SkypeControlAPIAttach nothing") unless @dwAttachMsg
+
+        addEvent(WM_COPYDATA)
+        addEvent(WM_USER_MSG)
+        addEvent @dwAttachMsg
+
+        create unless alive?
+      end
+
+      def attach
+        unless PostMessage.call(HWND_BROADCAST, @dwDiscoverMsg, hWnd, 0)
+          raise SkypeAPI::Error::Attach.new("SkypeControlAPIDiscover broadcast failure")
+        end
+        return true
+      end
+
+      def send_buffer
+        @send_buffer ||= Hash.new
+      end
+
+      def del_send_buffer num
+        @send_buffer.delete num
+      end
+
+      def invoke num, cmd
+        unless @hSkypeAPIWindowHandle
+          raise SkypeAPI::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")
+        end
+        @queue.push_hook(:sent, cmd.chop) if @queue.exist_hook? :sent
+        return true
+      end
+
+      def msghandler(sMsg)
+        case sMsg.msg
+        when @dwAttachMsg
+          case sMsg.lParam
+          when SKYPECONTROLAPI_ATTACH_SUCCESS
+            @hSkypeAPIWindowHandle = sMsg.wParam
+            invoke_protocol
+            @queue.push_hook(:attach,:success)
+
+            unless @skypeAPI.attached
+              if @skypeAPI.first_attached
+                @queue.push_hook(:attached)
+              else
+                @queue.push_hook(:reattached)
+              end
+            end
+            
+            @skypeAPI.attached = true
+            @skypeAPI.first_attached = false
+          when SKYPECONTROLAPI_ATTACH_PENDING_AUTHORIZATION
+            @queue.push_hook(:attach,:authorize)
+            @queue.push_hook(:authorize)
+          when SKYPECONTROLAPI_ATTACH_REFUSED
+            @queue.push_hook(:attach,:refused)
+            @queue.push_hook(:refused)
+            @skypeAPI.attached = false
+          when SKYPECONTROLAPI_ATTACH_NOT_AVAILABLE
+            @queue.push_hook(:attach, :not_available)
+            @queue.push_hook(:not_available)
+            @skypeAPI.attached = false
+          when SKYPECONTROLAPI_ATTACH_API_AVAILABLE
+            @queue.push_hook(:attach, :available)
+            @queue.push_hook(:available)
+          else
+            @queue.push_hook(:attach,:unkown)
+            @queue.push_hook(:unkown)
+          end
+          sMsg.retval = 1
+        when WM_COPYDATA
+          if sMsg.wParam == @hSkypeAPIWindowHandle
+            retval = application.cstruct2array(sMsg.lParam,"LLL")
+            cmd = application.pointer2string(retval[2],retval[1])
+            @queue.push cmd
+            sMsg.retval = 1
+          end
+        when WM_USER_MSG
+          unless SendMessage.call(sMsg.wParam, WM_COPYDATA, sMsg.hWnd, sMsg.lParam)
+            raise  SkypeAPI::Error::Attach.new("Skype not ready")
+          end
+          sMsg.retval = 1
+        else
+          super
+        end
+      end
+
+      def invoke_protocol
+        #@queue.push Proc.new{@skypeAPI.invoke_callback("PROTOCOL 9999"){}}
+        #@queue.push_block{@skypeAPI.invoke_callback("PROTOCOL 9999"){}}
+        @skypeAPI.__send__ :invoke_callback, "PROTOCOL 9999", Proc.new{}
+        #@queue.push_block{@skypeAPI.invoke_block("PROTOCOL 9999")}
+        #@skypeAPI.invoke_block("PROTOCOL 9999")
+      end
+      private :invoke_protocol
+    end
+
+  end
+end