Ruby4Skype 0.2.3 → 0.3.1

data/lib/skypeapi/os/windows.rb

@@ -1,170 +1,116 @@
 require 'swin'
 require 'Win32API'
+require 'timeout'
+require 'skypeapi/os/etc'
+require 'skypeapi/os/window_event_queue'
+require 'skypeapi/os/window_messagehandler'
 
 module SkypeAPI
   module OS
+    WAIT_CMD_LIMIT = 30.0 #sec
+    PING_CYCLE = 10.0 #sec
+    PING_LIMIT = 5.0 # < PING_CYCLE
+    SLEEP_INTERVAL = 0.001
+
+    HWND_BROADCAST = 0xFFFF
+    WM_COPYDATA = 0x004A
+    WM_CLOSE = 0x10
+    WM_USER = 0x0400
+    WM_USER_MSG = WM_USER + 1
+    SKYPECONTROLAPI_ATTACH_SUCCESS=0
+    SKYPECONTROLAPI_ATTACH_PENDING_AUTHORIZATION=1
+    SKYPECONTROLAPI_ATTACH_REFUSED=2
+    SKYPECONTROLAPI_ATTACH_NOT_AVAILABLE=3
+    SKYPECONTROLAPI_ATTACH_API_AVAILABLE=0x8001
+
+    RegisterWindowMessage = Win32API.new('user32','RegisterWindowMessageA', 'P', 'L')
+    SendMessage = Win32API.new("user32", "SendMessageA", ['L']*4, 'L')
+    PostMessage = Win32API.new("user32", "PostMessageA", 'LLLP', 'L')
+
     class Windows < Abstruct
-      require 'skypeapi/os/timer'
-      
-      WAIT_CMD_LIMIT = 10.0 #sec
-      PING_CYCLE = 5.0 #sec
-      PING_LIMIT = 3.0 # < PING_CYCLE
-      SLEEP_INTERVAL = 0.001
-      
-      HWND_BROADCAST = 0xFFFF
-      WM_COPYDATA = 0x004A
-      WM_USER = 0x0400
-      WM_USER_MSG = WM_USER + 1
-      SKYPECONTROLAPI_ATTACH_SUCCESS=0
-      SKYPECONTROLAPI_ATTACH_PENDING_AUTHORIZATION=1
-      SKYPECONTROLAPI_ATTACH_REFUSED=2
-      SKYPECONTROLAPI_ATTACH_NOT_AVAILABLE=3
-      SKYPECONTROLAPI_ATTACH_API_AVAILABLE=0x8001
-      
-      RegisterWindowMessage = Win32API.new('user32','RegisterWindowMessageA', 'P', 'L')
-      SendMessage = Win32API.new("user32", "SendMessageA", ['L']*4, 'L')
-      PostMessage = Win32API.new("user32", "PostMessageA", 'LLLP', 'L')
       
       def initialize
         @send_count = 0
-        @queue = Array.new
-        @callback = Hash.new
-        @notify = Hash.new
-        @event = Hash.new do |h,k|
-          h[k] = Array.new
-        end
+        @queue = WindowsEventQueue.new(self)
+
         @attached = false
         @first_attached = true
         @raise_when_detached = false
         
         @invoke_mutex = Mutex.new
-        @invoke_block_mutex = Mutex.new
-        
-        add_event :available do
+        @invoke_callback_mutex = Mutex.new
+        @cv = ConditionVariable.new
+        @detached_mutex = Mutex.new
+
+        add_hook :available do
           SkypeAPI.attach
         end
         
-        Timer.interval PING_CYCLE do
-          invoke_callback('PING'){} if @attached
-        end
-        
-        @reattach_mutex = Mutex.new
-        
-        @wmBuffer = Hash.new        
-        @wmHandler = SWin::LWFactory.new(SWin::Application.hInstance).newwindow nil
-        @wmHandler.create
-        @wmHandler.addEvent(WM_COPYDATA)
-        @wmHandler.addEvent(WM_USER_MSG)
-        @wmHandler.instance_variable_set :@skypeAPI,self
-        @wmHandler.instance_variable_set :@wmBuffer,@wmBuffer
-        @wmHandler.instance_variable_set :@queue,@queue
+        @wmHandler = SWin::LWFactory.new(SWin::Application.hInstance).newwindow nil, MessageHandler
+        @wmHandler.init self, @queue
         
-        class << @wmHandler
-          attr_reader :hSkypeAPIWindowHandle
-          
-          def msghandler(sMsg)
-            case sMsg.msg
-            when @dwAttachMsg
-              case sMsg.lParam
-              when SKYPECONTROLAPI_ATTACH_SUCCESS
-                @hSkypeAPIWindowHandle = sMsg.wParam
-                @queue.push Proc.new{@skypeAPI.invoke_callback("PROTOCOL 9999"){}}
-                
-                @queue.push Proc.new{@skypeAPI.do_event(:attach,:success)}
-                unless @skypeAPI.attached
-                  if @skypeAPI.first_attached
-                    @queue.push Proc.new{@skypeAPI.do_event(:attached)}
-                  else
-                    @queue.push Proc.new{@skypeAPI.do_event(:reattached)}
-                  end
-                end
-                @skypeAPI.attached = true
-                @skypeAPI.first_attached = false
-              when SKYPECONTROLAPI_ATTACH_PENDING_AUTHORIZATION
-                @queue.push Proc.new{@skypeAPI.do_event(:attach,:authorize)}
-                @queue.push Proc.new{@skypeAPI.do_event(:authorize)}
-              when SKYPECONTROLAPI_ATTACH_REFUSED
-                @queue.push Proc.new{@skypeAPI.do_event(:attach,:refused)}
-                @queue.push Proc.new{@skypeAPI.do_event(:refused)}
-                @skypeAPI.attached = false
-              when SKYPECONTROLAPI_ATTACH_NOT_AVAILABLE
-                @queue.push Proc.new{@skypeAPI.do_event(:attach, :not_available)}
-                @queue.push Proc.new{@skypeAPI.do_event(:not_available)}
-                @skypeAPI.attached = false
-              when SKYPECONTROLAPI_ATTACH_API_AVAILABLE
-                @queue.push Proc.new{@skypeAPI.do_event(:attach, :available)}
-                @queue.push Proc.new{@skypeAPI.do_event(:available)}
-              else
-                @queue.push Proc.new{@skypeAPI.do_event(:attach,:unkown)}
-                @queue.push Proc.new{@skypeAPI.do_event(:unkown)}
-              end
-              sMsg.retval = 1
-              #return true
-            when WM_COPYDATA
-              if sMsg.wParam == @hSkypeAPIWindowHandle
-                retval = application.cstruct2array(sMsg.lParam,"LLL")
-                cmd = application.pointer2string(retval[2],retval[1])
-                @skypeAPI.push_queue cmd
-                sMsg.retval = 1
-                return true
-              end
-            when WM_USER_MSG
-              unless SendMessage.call(sMsg.wParam, WM_COPYDATA, sMsg.hWnd, sMsg.lParam)
-                raise  SkypeAPIError::Connect,"Skype not ready"
-              end
-              sMsg.retval = true
-              return true
-            end
-          end
-        end
-        
-        @wmHandler.create unless @wmHandler.alive?
-        @dwDiscoverMsg = RegisterWindowMessage.call("SkypeControlAPIDiscover");
-        raise SkypeAPIError::Attach,"SkypeControlAPIDiscover nothing" unless @dwDiscoverMsg
-        @dwAttachMsg = RegisterWindowMessage.call("SkypeControlAPIAttach")
-        raise SkypeAPIError::Attach,"SkypeControlAPIAttach nothing" unless @dwAttachMsg
-        @wmHandler.instance_variable_set :@dwAttachMsg, @dwAttachMsg
-        @wmHandler.addEvent @dwAttachMsg
+        #@queue.start_process_thread
+        start_wmhandler_loop
+        start_ping_thread
       end
-      
+
+      attr_reader :invoke_callback_mutex, :cv, :wmHandler
       attr_accessor :attached, :first_attached#,:received,:sent
+
+      #引数にmethodかブロックを渡しておくとSkypeAPIのNotification(コマンドのレスポンは除く)があった場合呼ばれる。
+      #ブロックはNotificationの文字列を一つ与えられて呼ばれる。
+      def set_notify_selector block=Proc.new
+        @queue.set_notify_selector block
+      end
       
+      #主にAttachなど、Skypeとのコネクション関係のイベントの通知を受ける為のブロックを設定する。
+      #引数 sym は :attach, :attached, :authorize, :refused, :not_available, :available, :unknown, :detachedを取る。
+      #引数 sym が :attachの場合、ブロックは一つの引数(:success,:authorize,:refused,:not_available,:available,:unknownのどれか)を与えられて呼ばれる。
+      def add_hook sym, block=Proc.new
+        @queue.add_hook sym, block
+      end
+
+      def del_hook sym, block=nil
+        @queue.del_hook sym, block
+      end
+
+      def exist_hook? sym
+        @queue.exist_hook? sym
+      end
+
+      def get_hook sym
+        @queue.get_hook sym
+      end
+
+      alias add_event add_hook
+      alias del_event del_hook
+      alias exist_event? exist_hook?
+      alias get_event get_hook
+
+      #SkypeAPIにAttachする。ブロックはしないのでつながるまで待つならばadd_hookでイベントを追加するか,attach_waitを使う。
       def attach name = nil #,&block)
-        #post?
-        unless PostMessage.call(HWND_BROADCAST, @dwDiscoverMsg, @wmHandler.hWnd, 0)
-          raise SkypeAPIError::Attach,"SkypeControlAPIDiscover broadcast fail"
-        end
-        return true
+        @wmHandler.attach
       end
-      
+
       def attach_wait name = nil
-        flag = true
-        add_event :attached do
-          flag = false
-        end
         attach name
-        while flag
-          polling
-          sleep SLEEP_INTERVAL
-        end
+        sleep SLEEP_INTERVAL until @attached
       end
-      
-      def invoke_prototype num, cmd
-        unless @wmHandler.hSkypeAPIWindowHandle
-          raise SkypeAPIError::Attach,"NullPointerException SendSkype!"
-          return false
-        end
-        
-        cmd = '#' + num.to_s + ' ' + cmd + "\0"
-        pCopyData = @wmHandler.application.arg2cstructStr("LLS",0,cmd.length+1,cmd)
-        unless PostMessage.call(@wmHandler.hWnd, WM_USER_MSG, @wmHandler.hSkypeAPIWindowHandle, pCopyData)
-          @wmHandler.instance_variable_set :@hSkypeAPIWindowHandle,nil
-          raise SkypeAPIError::Attach,"Skype not ready"
-        end
-        @queue.push(proc{do_event(:sent, cmd)}) if exist_event? :sent
+
+      def detached?
+        return true unless @attached
+        old_received_count = @queue.received_count
+        return false if _ping
+        return false if @queue.received_count - old_received_count > 0
         return true
       end
-      
+      private :detached?
+
+      #SkypeAPIにコマンドを発行する。Skypeから返り値が戻ってくるまでブロックする。
+      def invoke cmd
+        super cmd
+      end
+
       def invoke_callback cmd,cb=Proc.new
         send_count = nil
         @invoke_mutex.synchronize do
@@ -172,198 +118,116 @@ module SkypeAPI
           @send_count += 1
         end
         
-        @callback[send_count] = cb
+        @queue.callback[send_count] = cb
         begin
-          invoke_prototype send_count, cmd
+          @wmHandler.invoke send_count, cmd
         rescue => e
-          @callback.delete(send_count)
+          @queue.callback.delete(send_count)
           raise e
         end
-        return true
+        return send_count
       end
-=begin
-      def invoke_block cmd, waitLimit=nil
-        @invoke_block_mutex.synchronize do
-          res_val = nil
-          current_thread = Thread.current
-          invoke_callback cmd do |res|
-            res_val = res
-            current_thread.run
-          end
-          begin
-            timeout 10 do
-              sleep
-            end
-          rescue TimeoutError
-            if ping
-              retry
+      private :invoke_callback
+
+      def invoke_block cmd, wait_limit = WAIT_CMD_LIMIT
+        result = nil
+        retry_flag = false
+        send_count = invoke_callback(cmd){ |res| result = res }
+        begin
+          timeout(wait_limit){ @invoke_callback_mutex.synchronize{ @cv.wait @invoke_callback_mutex until result } }
+        rescue Timeout::Error
+          if detached?
+            if @raise_when_detached
+              raise SkypeAPI::Error::Timeout.new("timeout #{send_count} #{cmd}")
             else
-              reattach
-              return invoke_block(cmd)
+              status2detache
+              retry_flag = true
             end
           else
-            return res_val
+            retry
           end
         end
+        return retry_flag ? invoke_block(cmd) : result
       end
-      
-      def reattach
-        @attached = false
-        @queue.push(proc{do_event(:detached)})
-        if @raise_when_detached
-          raise SkypeAPI::Error::Attach
-        else
-          SkypeAPI.attach
-          loop do
-            if @attached
-              break
-            end
-            sleep SLEEP_INTERVAL
-          end
-          p 'reattached'
-        end
-      end
-=end
-#=begin
-      def invoke_block cmd, waitLimit = WAIT_CMD_LIMIT
-        resVal = nil
-        invoke_callback cmd do |res|
-          resVal = res
-        end
-        startTime = Time.now
-        loop do
-          polling
-          if resVal
-            return resVal
-          end
-          
-          if Time.now - startTime > waitLimit
-            if ping
-              startTime = Time.now
-            else
-              if @attached
-                @attached = false
-                @queue.push(proc{do_event(:detached)})
-                SkypeAPI.attach
-              end
-              
-              if @raise_when_detached
-                raise SkypeAPI::Error::Attach
-              else
-                loop do
-                  polling
-                  if @attached
-                    break
-                  end
-                  sleep SLEEP_INTERVAL
-                end
-                ret = invoke_block(cmd, waitLimit)
-                return ret 
-              end
-            end
+      private :invoke_block
+
+      def status2detache
+        @detached_mutex.synchronize do
+          if detached?
+            @attached = false
+            @queue.push_detached_hook
+            attach_wait
+          else
+            #wait?
+            #runtimeerro?
           end
-          
-          #Thread.pass
-          sleep SLEEP_INTERVAL
         end
       end
-#=end
-      def wait someAction=nil
-        if someAction.class == Proc
-          @wmHandler.application.messageloop do 
-            queue_process
-            Timer.polling
-            someAction.call
-          end
-        elsif block_given?
-          @wmHandler.application.messageloop do
-            queue_process
-            Timer.polling
-            yield
-          end
-        else
-          @wmHandler.application.messageloop do
-          	queue_process
-          	Timer.polling
-          end
-        end
+
+      #notificationのメッセージループを新しいスレッドで回し始めます。
+      def start_messageloop
+        @queue.start_messageloop
       end
-      
-      def polling
-        @wmHandler.application.doevents
-        Thread.pass
-        queue_process
-        Timer.polling
+
+      #notificationのメッセージループをカレントスレッドで回しはじめます。すなわち帰ってきません。
+      def messageloop
+        @queue.messageloop
       end
-      
-      def close
-        @wmHandler.close
+
+      #notificationのメッセージループを一度だけ回します。
+      def messagepolling
+        @queue.messagepolling
       end
       
-      def push_queue res
-        @queue.push(proc{do_event(:received, res.chop)})
-        if res =~ /^(#(\d+?) )?(.+?)\000$/m
-          if $2
-            if @callback[$2.to_i]
-              cb = @callback[$2.to_i]
-              val = $3
-              @callback.delete($2.to_i)
-              #@queue.push(proc{cb.call val})
-              cb.call val
-            end
-          else
-            cmd = $3
-            
-            if cmd == 'CONNSTATUS LOGGEDOUT'
-              @attached = false
-              @queue.push(proc{do_event(:detached)})
-              SkypeAPI.attach
-            end
-            
-            flag = false
-            @notify.each do |reg,action|
-              if cmd =~ reg
-                tmp = $1
-                @queue.push(proc{action.call(tmp)})
-                flag = true
-              end
-            end
-            
-            unless flag
-              action = @notify[nil]
-              @queue.push(proc{action.call(cmd)})
-            end
+      alias polling messagepolling
+
+      def start_wmhandler_loop
+        @doevents_thread = Thread.new do
+          @message_loop_in = true
+          @wmHandler.application.messageloop do
+            sleep 0.01
           end
+          @message_loop_in = false
         end
       end
-      
-      private
-      def queue_process
-        while callback = @queue.shift
-          #Thread.new do
-            callback.call
-          #end
+      private :start_wmhandler_loop
+
+
+      def start_ping_thread
+        Thread.new do
+          loop do
+            ping if @attached
+            sleep PING_CYCLE
+          end
         end
       end
-#=begin
+      private :start_ping_thread
+
+      #とりあえず、新しくインスタンスを作るとき、古いものはcloseしないといけない。
+      def close
+        break_messageloop
+        #@wmHandler.close
+        @queue.close
+      end
+
+      def break_messageloop
+        PostMessage.call(@wmHandler.hWnd, WM_CLOSE, 0,0)
+        sleep 0.123 while @message_loop_in
+      end
+      private :break_messageloop
+
       def ping
-        resVal = nil
-        invoke_callback 'PING' do |res|
-          resVal = res
-        end
-        startTime = Time.now
-        loop do
-          polling##
-          if resVal
-            return resVal
-          end
-          if Time.now - startTime > PING_LIMIT
-            return false
-          end
-          sleep SLEEP_INTERVAL
-        end
+        invoke_block('PING',PING_LIMIT) == 'PONG'
       end
-#=end
+
+      def _ping
+        result = nil
+        invoke_callback('PING'){|res| result = res}
+        sleep PING_LIMIT
+        result == 'PONG'
+      end
+      private :ping
+
     end
   end
 end