Ruby4Skype 0.2.2 → 0.2.3

data/lib/skypeapi/os.rb

@@ -1,439 +0,0 @@
-module SkypeAPI
-  module OS
-    module Share
-      WAIT_CMD_LIMIT = 30.0 #sec
-      PING_CYCLE = 30.0 #sec
-      PING_LIMIT = 10.0 # < PING_CYCLE
-      SLEEP_INTERVAL = 0.001
-      
-      def sendCMD cmd,method=nil,&block
-        if method
-          sendCallBack cmd do |res|
-            check res,cmd
-            method.call res
-          end
-          return true
-        elsif block_given?
-          sendCallBack cmd do |res|
-            check res,cmd
-            block.call res
-          end
-          return true
-        else
-          return check(sendBlock(cmd),cmd)
-        end
-      end
-      
-      def check res,cmd
-        if res =~ /^ERROR /m
-          raise SkypeAPIError::API,res,cmd
-        else
-          return res
-        end
-      end
-      
-      def sendCallBack cmd,cb=Proc.new
-        @callBack[@sendCount] = cb
-        begin
-          sendMSG cmd
-        rescue => e
-          @callBack.delete(@sendCount)
-          raise e
-        end
-        return true
-      end
-
-      def sendBlock cmd, waitLimit = WAIT_CMD_LIMIT
-        resVal = nil
-        sendCallBack cmd do |res|
-          resVal = res
-        end
-        startTime = Time.now
-        loop do
-          polling
-          if resVal
-            return resVal
-          end
-          if Time.now - startTime > waitLimit
-            unless existEvent? :reconnect
-              raise SkypeAPIError::TimeOut,"TimeOut #{cmd} {(Time.now - startTime).to_i}"
-            else
-              doEvent :reconnect
-              return sendBlock(cmd, waitLimit)
-            end
-          end
-          #Thread.pass
-          sleep SLEEP_INTERVAL
-          #sleep 0.00123
-          #sleep 0.000001
-          #sleep 0.01
-        end
-      end
-
-      def attachWait
-        flag = true
-        attach do |state|
-          flag = false if state == :success
-        end
-        while flag
-          polling
-          sleep SLEEP_INTERVAL
-          #sleep 0.0123
-        end
-      end
-      
-      #����reg==nil�ŁA���̑��ƌ���㩁B
-      def addNotify reg, block=Proc.new
-        @notify[reg] = block
-      end
-      
-      def delNotify reg
-        @notify.delete reg
-      end
-      
-      def addEvent sym, block=Proc.new
-        @event[sym].push block
-        block
-      end
-      
-      def setEvent sym, block=Proc.new
-        @event[sym] = Array.new
-        addEvent sym, block
-      end
-      
-      def delEvent sym, block=nil
-        unless block
-          @event[sym] = Array.new
-        else
-          @event[sym].delete block
-        end
-      end
-      
-      def replaceEvent sym,block=Proc.new
-        tmp = @event[sym].dup
-        if defined?(block.each)
-          block.each do |e|
-            addEvent sym, e
-          end
-        else
-          setEvent sym,block
-        end
-        return tmp
-      end
-      
-      def existEvent? sym
-        if @event[sym].length > 0
-          return true
-        else
-          return false
-        end
-      end
-      
-      def getEvent sym
-        @event[sym]
-      end
-      
-      def doEvent sym,*args
-        @event[sym].each do |e|
-          if e.arity == 1
-            e.call args[0]
-          else
-            e.call args
-          end
-        end
-      end
-
-      def pushQueue res
-        @queue.push(proc{doEvent(:received, res.chop)}) if existEvent? :received
-        
-        if res =~ /^(#(\d+?) )?(.+?)\000$/m
-          if $2
-            if @callBack[$2.to_i]
-              cb = @callBack[$2.to_i]
-              val = $3
-              if @singleThread
-                @sent = proc{cb.call val}
-              else
-                @queue.push(proc{cb.call val})
-              end
-              @callBack.delete($2.to_i)
-            end
-          else
-            cmd = $3
-            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
-          end
-        end
-      end
-      
-      def queueProcess
-        @pingTime = Time.now unless @pingTime
-        if Time.now - @pingTime > PING_CYCLE
-          @queue.push method(:checkConnection)
-          @pingTime = Time.now
-        end
-        
-        if @singleThread
-          if @sent == nil
-            while e = @queue.shift
-              e.call
-            end
-          elsif(@sent.class == Proc)
-            @sent.call
-            @sent = nil
-          end
-        else
-          while e = @queue.shift
-            e.call
-          end
-        end
-      end
-      
-      def checkConnection
-        begin
-          resVal = nil
-          sendCallBack 'PING' do |res|
-            resVal = res
-          end
-          startTime = Time.now
-          i = 0
-          loop do
-            polling
-            if resVal
-              unless resVal == "PONG"
-                raise SkypeAPIError::Reconnect 
-              else
-                break
-              end
-            end
-            if Time.now - startTime > PING_LIMIT and i > 3
-              raise SkypeAPIError::TimeOut
-            end
-            i+=1
-            sleep SLEEP_INTERVAL
-          end
-        rescue SkypeAPIError::Reconnect,SkypeAPIError::TimeOut
-          unless existEvent? :reconnect
-            raise SkypeAPIError::Reconnect
-          else
-            doEvent :reconnect
-          end
-        end
-        return true
-      end
-      
-    end
-    
-    class Windows
-      begin
-      	require 'rubygems'
-      	gem 'swin'
-      rescue LoadError
-      end
-      require "swin"
-      require 'Win32API'
-      include Share
-      
-      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
-        @sendCount = 0
-        @queue = Array.new
-        @callBack = Hash.new
-        @notify = Hash.new
-        @event = Hash.new do |h,k|
-          h[k] = Array.new
-        end
-        @singleThread = true
-        
-        addEvent :reconnect do
-          flag = true
-          attachEvent = replaceEvent :attached do
-            flag = false
-          end
-          attach
-          while flag
-            polling
-            sleep 0.123
-          end
-          replaceEvent :attach, attachEvent
-        end
-        
-        @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
-        
-        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.sendCMD "PROTOCOL 9999"}
-                @queue.push Proc.new{@skypeAPI.doEvent(:attach,:success)}
-                @queue.push Proc.new{@skypeAPI.doEvent(:attached)}
-              when SKYPECONTROLAPI_ATTACH_PENDING_AUTHORIZATION:
-                @queue.push Proc.new{@skypeAPI.doEvent(:attach,:authorize)}
-                @queue.push Proc.new{@skypeAPI.doEvent(:pendingAuthorization)}
-              when SKYPECONTROLAPI_ATTACH_REFUSED:
-                unless @skypeAPI.existEvent? :attach
-                  raise SkypeAPIError::Attach,"Refused"
-                else
-                  @queue.push Proc.new{@skypeAPI.doEvent(:attach,:refused)}
-                end
-              when SKYPECONTROLAPI_ATTACH_NOT_AVAILABLE:
-                unless @skypeAPI.existEvent? :attach
-                  raise SkypeAPIError::Attach,"Not available."
-                else
-                  @queue.push Proc.new{@skypeAPI.doEvent(:attach,:notAvailable)}
-                end
-              when SKYPECONTROLAPI_ATTACH_API_AVAILABLE:
-                @queue.push Proc.new{@skypeAPI.doEvent(:apiAvailable)}
-              else
-                unless @skypeAPI.existEvent? :attach
-                  raise SkypeAPIError::Attach,"Skype API attach unknown message"
-                else
-                  @queue.push Proc.new{@skypeAPI.doEvent(:attach,:unkown)}
-                end
-              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])
-                @wmBuffer.delete($1.to_i) if cmd =~ /^#(\d+) /
-                @skypeAPI.pushQueue 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
-      end
-      
-      #attr_accessor :attached,:received,:sent
-      
-      def attach &block
-        if block
-          if block.arity == 1
-            addEvent :attach, block
-          else
-            addEvent :attached, block
-          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
-        #post?
-        unless PostMessage.call(HWND_BROADCAST, dwDiscoverMsg, @wmHandler.hWnd, 0)
-          raise SkypeAPIError::Attach,"SkypeControlAPIDiscover broadcast fail"
-        end
-        return true
-      end
-      
-      def sendMSG cmd
-        unless @wmHandler.hSkypeAPIWindowHandle
-          raise SkypeAPIErorr::Connect,"NullPointerException SendSkype!"
-          return false
-        end
-        
-        cmd = '#' + @sendCount.to_s + ' ' + cmd
-        @wmBuffer[@sendCount] = cmd
-        @sent = true if @singleThread
-        pCopyData = @wmHandler.application.arg2cstructStr("LLS",0,@wmBuffer[@sendCount].length+1,@wmBuffer[@sendCount])
-        unless PostMessage.call(@wmHandler.hWnd, WM_USER_MSG, @wmHandler.hSkypeAPIWindowHandle, pCopyData)
-          @wmHandler.instance_variable_set :@hSkypeAPIWindowHandle,nil
-          raise SkypeAPIError::Connect,"Skype not ready"
-          return false;
-        end
-        @queue.push(proc{doEvent(:sent, cmd)}) if existEvent? :sent
-        @sendCount+=1
-        return true
-      end
-      
-      
-      def wait someAction=nil
-        if someAction.class == Proc
-          @wmHandler.application.messageloop do 
-            queueProcess
-            someAction.call
-          end
-        elsif block_given?
-          @wmHandler.application.messageloop do
-            queueProcess
-            yield
-          end
-        else
-          @wmHandler.application.messageloop{queueProcess}
-        end
-      end
-      
-      def polling
-        @wmHandler.application.doevents
-        queueProcess
-      end
-
-      def close
-        @wmHandler.close
-      end
-    end
-    
-    class Mac
-      #wiki like
-      def initialize
-        raise SkypeAPIError::NotImplement
-      end
-    end
-    
-    class Linux
-      #plz write it
-      def initialize
-        raise SkypeAPIError::NotImplement
-      end
-    end
-  end
-  
-end