Ruby4Skype 0.2.1

data/lib/skypeapi/application.rb

@@ -0,0 +1,415 @@
+module SkypeAPI
+  module Object
+    class Stream
+      def initialize app, streamString
+        @app = app
+        @id = streamString
+        @user = SkypeAPI.user(@id.split(':')[0])
+      end
+      
+      def to_s
+        @string
+      end
+      
+      def user
+        @user
+      end
+      
+      def write cmd, &block
+        @app.write self, cmd, block
+      end
+      
+      def datagram cmd, &block
+        @app.datagram self, cmd, block
+      end
+      
+      def read &block
+        @app.read self, block
+      end
+      
+      def disconnect &block
+        @app.disconnect self, block
+      end
+    end
+    
+    class Application < AbstractObject
+      OBJECT_NAME = "APPLICATION"
+      
+      getter :Connectable , 'CONNECTABLE' do |str|
+        str.split(' ').collect{|i| SkypeAPI.user(i)}
+      end
+      
+      getter :Connecting,'CONNECTING' do |str|
+        str.split(' ').collect{|i| SkypeAPI.user(i)}
+      end
+      
+      getter :Streams, 'STREAMS' do |str|
+        str.split(' ').collect{|i| Stream.new(self, i)}
+      end
+      
+      getter :Received, 'RECEIVED' do |str|
+        str.split(' ').collect do |i|
+          streamID, byte = i.split('=')
+          {:stream => Stream.new(self, streamID),:bytes => byte.to_i}
+        end
+      end
+      
+      getter :Sending, 'SENDING' do |str|
+        str.split(' ').collect do |i|
+          streamID, byte = i.split('=')
+          {:stream => Stream.new(self, streamID),:bytes => byte.to_i}
+        end
+      end
+      
+      def self.create id
+        app = new id
+        app.create
+        app
+      end
+      
+      def create
+        sendEcho "CREATE APPLICATION #{@id}"
+      end
+      
+      def connect handle
+        sendEcho "ALTER APPLICATION #{@id} CONNECT #{handle}"
+      end
+      
+      def write stream, cmd
+        sendAlter "WRITE", "#{stream} #{cmd}"
+      end
+      
+      def datagram stream, cmd
+        sendAlter "DATAGRAM", "#{stream} #{cmd}"
+      end
+      
+      def read stream
+        res = sendCMD "ALTER APPLICATION #{@id} READ #{stream}"
+        res =~ /^ALTER APPLICATION #{@id} READ #{stream} (.*)$/
+        $1
+      end
+      
+      def disconnect stream
+        sendEcho "ALTER APPLICATION #{@id} DISCONNECT #{stream}"
+      end
+      
+      def delete
+        sendEcho "DELETE APPLICATION #{@id}"
+      end
+    end
+    
+    class A2A
+      extend Forwardable
+      include SkypeAPI::ShareFunctions
+      def initialize appName,base
+        @appName = appName
+        @eventListener = Hash.new
+        @base = base
+        @base.addNotify /^APPLICATION #{@appName} (.+)$/,method(:receiv)
+      end
+      
+      def_delegators :@base, :sendCMD, :sendCallBack,:sendBlock,:addNotify,:delNotify
+      #:attach, :wait,:polling, :attached, :attached=, :received, :received=, :sent, :sent=
+      
+      def getConnectable
+        sendSplit "GET APPLICATION #{@appName} CONNECTABLE","APPLICATION #{@appName} CONNECTABLE"
+      end
+      def getConnecting
+        sendSplit "GET APPLICATION #{@appName} CONNECTING","APPLICATION #{@appName} CONNECTING"
+      end
+      def getStreams
+        sendSplit "GET APPLICATION #{@appName} STREAMS","APPLICATION #{@appName} STREAMS"
+      end
+      def getReceived
+        streamByte2hash sendSplit("GET APPLICATION #{@appName} RECEIVED","APPLICATION #{@appName} RECEIVED")
+      end
+      def getSending
+        streamByte2hash sendSplit("GET APPLICATION #{@appName} SENDING","APPLICATION #{@appName} SENDING")
+      end
+      def create
+        sendEcho "CREATE APPLICATION #{@appName}"
+      end
+      def connect handle
+        sendEcho "ALTER APPLICATION #{@appName} CONNECT #{handle}"
+      end
+      def write stream, cmd, &block
+        if block_given?
+          sendCMD("ALTER APPLICATION #{@appName} WRITE #{stream} #{cmd}",&block)
+        else
+          sendEcho "ALTER APPLICATION #{@appName} WRITE #{stream} #{cmd}"
+        end
+      end
+      def datagram stream, cmd
+        sendEcho "ALTER APPLICATION #{@appName} DATAGRAM #{stream} #{cmd}"
+      end
+      def read stream, &block
+        if block_given?
+          sendCMD "ALTER APPLICATION #{@appName} READ #{stream}" do |res|
+            res =~ /^ALTER APPLICATION #{@appName} READ #{stream} (.*)$/m
+            block.call $1
+          end
+        else
+          sendCMD "ALTER APPLICATION #{@appName} READ #{stream}"
+        end
+      end
+      def disconnect stream
+        sendEcho "ALTER APPLICATION #{@appName} DISCONNECT #{stream}"
+      end
+      def delete
+        sendEcho "DELETE APPLICATION #{@appName}"
+        delNotify /^APPLICATION #{appName} (.+)$/
+      end
+      
+      def onEvent name,cb=Proc.new
+        @eventListener[name] = cb
+      end
+      
+      def receiv res
+        case res
+        when /^CONNECTING (.+)$/m
+          @eventListener[:connecting].call $1.split(" ") if @eventListener[:connecting]
+        when /^STREAMS (.+)$/m
+          @eventListener[:connected].call $1.split(" ") if @eventListener[:connected]
+        when /^RECEIVED (.+)$/m
+          @eventListener[:received].call streamByte2hash($1.split(" ")) if @eventListener[:received]
+        when /^READ (.+?) (.+)$/m
+          @eventListener[:read].call $1, $2 if @eventListener[:read]
+        when /^DATAGRAM (.+?) (.+)$/m
+          @eventListener[:datagram].call $1, $2 if @eventListener[:datagram]
+        when /^SENDING (.+?)$/m
+          @eventListener[:sending].call streamByte2hash($1.split(" ")) if @eventListener[:sending]
+        end
+      end
+      
+      private
+      def streamByte2hash arr
+        ret = Hash.new do |hash,key|
+          hash[key] = 0
+        end
+        arr.each do |streamByte|
+          streamByte = streamByte.split "="
+          ret[streamByte[0]] = streamByte[1].to_i
+        end
+        return ret
+      end
+    end
+
+    class A2AEx < A2A
+      TRANS_LIMIT = 65000
+      SPLIT_LIMIT = 65000-2
+      
+      extend Forwardable
+      include SkypeAPI::ShareFunctions
+      def initialize appName,base
+        super
+        @handle2stream = Hash.new
+        @sndBuffer = Hash.new do |hash,key|
+          hash[key] = Array.new
+        end
+        @rcvBuffer = Hash.new do |hash,key|
+          hash[key] = Array.new
+        end
+        @created = false
+      end
+      
+      attr_reader :created, :sndBuffer, :rcvBuffer
+      
+      def getStreams
+        streams = super
+        streamTreat streams
+        return @handle2stream.keys
+      end
+      
+      def getConnection
+        @handle2stream.keys
+      end
+      
+      def create
+        super
+        @created = true
+      end
+
+      def connect handles=getConnection
+        handles = [handles] unless handles.class == Array
+        handles.each do |handle|
+          super handle
+        end
+      end
+
+      def connectAndWait handles
+        waitFlag = false
+        @base.addNotify /^APPLICATION #{@appName} CONNECTING $/,(Proc.new do
+          waitFlag = true
+        end)
+        handles = [handles] unless handles.class == Array
+        handles.each do |handle|
+          sendCMD "ALTER APPLICATION #{@appName} CONNECT #{handle}"
+        end
+
+        startTime = Time.now
+        i = 0
+        loop do
+          @base.polling
+          break if waitFlag or Time.now - startTime > 3
+          sleep 0.001
+          i+=1
+        end
+        @base.delNotify /^APPLICATION #{@appName} CONNECTING $/
+      end
+
+      def disconnect handles=getStreams
+        handles = [handles] unless handles.class == Array
+        handles.each do |h|
+          begin
+            super @handle2stream[h]
+            @handle2stream.delete h
+          rescue =>e
+            p e
+          end
+        end
+      end
+
+      def transmit cmd, handles=getConnecting
+        handles = [handles] unless handles == Array
+        handles.each do |handle|
+          if cmd.size > SPLIT_LIMIT
+            tmp = Array.new
+            while cmd.size > SPLIT_LIMIT
+              tmp.push cmd[0,SPLIT_LIMIT] + "D"
+              cmd = cmd[SPLIT_LIMIT,cmd.length]
+            end
+            tmp.push cmd
+            cmd = tmp
+          else
+            cmd = [cmd]
+          end
+          handle = [handle] unless handle.class == Array
+          handle.each do |h|
+            @sndBuffer[h].concat cmd
+          end
+        end
+      end
+      
+      def polling
+        if @created
+          f = false
+          @sndBuffer.each_value do |buffer|
+            if buffer.length > 0
+              f = true
+              break
+            end
+          end
+          if f
+            h2b = getSending
+            streams = Hash.new
+            @sndBuffer.each do |handle,buffer|
+              if @handle2stream[handle]
+                while buffer.length > 0
+                  if buffer[0].size + h2b[handle] < TRANS_LIMIT
+                    h2b[handle] += buffer[0].size
+                    write handle,buffer.shift do |res|
+                      #do nothing
+                    end
+                  else
+                    break
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+      
+      def read handle, &block
+        handle = @handle2stream[handle]
+        unless handle
+          raise SkypeAPIError, "Read Error nonConnecting #{handle}"
+        else
+          super
+        end
+      end
+      
+      def write handle, cmd, &block
+        stream = @handle2stream[handle]
+        unless stream
+          raise SkypeAPIError,"Write Error nonConnecting #{handle} #{cmd}"
+        else
+          super stream, cmd, &block
+        end
+      end
+      
+      def datagram handle, cmd
+        handle = @handle2stream[handle]
+        super
+      end
+
+      private :write, :datagram, :read
+      
+      def receiv res
+        case res
+        when /^CONNECTING (.*)$/m
+          @eventListener[:connecting].call $1.split(" ") if @eventListener[:connecting]
+        when /^STREAMS (.*)$/m
+          streams = $1.split " "
+          streamTreat streams
+          @eventListener[:connected].call @handle2stream.keys if @eventListener[:connected]
+        when /^RECEIVED (.+)$/m
+          res = $1
+          res.split(" ").each do |info|
+            stream = info.split("=")[0]
+            byte = info.split("=")[1]
+            handle = info.split(":")[0]
+            read handle do |content|
+              if content and not content.empty?
+                if content.size > SPLIT_LIMIT
+                  @rcvBuffer[handle].push content[0,content.size-1]
+                else
+                  if @rcvBuffer.length > 0
+                    @rcvBuffer[handle].push content
+                    tmp = @rcvBuffer[handle].join ""
+                    @rcvBuffer[handle].clear
+                    @eventListener[:read].call handle, tmp if @eventListener[:read]
+                  else
+                    @eventListener[:read].call handle, content if @eventListener[:read]
+                  end
+                end
+              end
+            end
+          end
+          @eventListener[:received].call streamByte2hash(res.split(" ")) if @eventListener[:received] and res
+        when /^READ (.+?) (.+)$/m
+          #@eventListener[:read].call $1.split(":")[0], $2 if @eventListener[:read]
+        when /^DATAGRAM (.+?) (.+)$/m
+          @eventListener[:datagram].call $1.split(":")[0], $2 if @eventListener[:datagram]
+        when /^SENDING (.+?)$/m
+          @eventListener[:sending].call streamByte2hash($1.split(" ")) if @eventListener[:sending]
+        end
+      end
+      
+      private
+      def streamTreat streams
+        @handle2stream.each do |handle,stream|
+          unless streams.include? stream
+            @sndBuffer[handle].clear
+            @rcvBuffer[handle].clear
+          end
+        end
+        @handle2stream.clear
+        streams.each do |st|
+          @handle2stream[st.split(":")[0]] = st
+        end
+      end
+      
+      def streamByte2hash arr
+        ret = Hash.new do |hash, key|
+          hash[key] = 0
+        end
+        arr.each do |streamByte|
+          streamByte = streamByte.split "="
+          ret[streamByte[0].split(":")[0]] = streamByte[1].to_i
+        end
+        return ret
+      end
+    end
+  end
+end

data/lib/skypeapi/call.rb

@@ -0,0 +1,220 @@
+module SkypeAPI
+  module Object
+    class Call < AbstractObject
+      OBJECT_NAME = "CALL"
+      
+      def self.create *targets
+        targets = targets[0] if targets[0].class == Array
+        res = (@@skypeApi.sendOne "CALL " + targets.join(", "),"CALL").split(" ")
+        #return @@skypeApi.call(res[0]),res[2]
+        new res[0]
+      end
+      
+      getter :Timestamp, 'TIMESTAMP' do |str|
+        str.to_i
+      end
+      getter :Partner, 'PARTNER_HANDLE' do |str|
+        @@skypeApi.user str
+      end
+      getter :PartnerDispname, 'PARTNER_DISPNAME'
+      getter :TargetIdentity, 'TARGET_IDENTITY'
+      getter :ConfID, 'CONF_ID' do |str|
+        str.to_i
+      end
+      getter :Type, 'TYPE'
+      getter :Status, 'STATUS'
+      getter :VideoStatus, 'VIDEO_STATUS'
+      getter :VideoSendStatus, 'VIDEO_SEND_STATUS'
+      getter :VideoReceiveStatus, 'VIDEO_RECEIVE_STATUS'
+      getter :FailureReason, 'FAILUREREASON' do |str|
+        str.to_i
+      end
+      getter :Subject, 'SUBJECT'
+      getter :PSTNNumber, 'PSTN_NUMBER'
+      getter :Duration, 'DURATION' do |str|
+        str.to_i
+      end
+      getter :PSTNStatus, 'PSTN_STATUS'
+      getter :ConfParticipantsCount, 'CONF_PARTICIPANTS_COUNT' do |str|
+        str.to_i
+      end
+      
+      notice :ConfParticipant, 'CONF_PARTICIPANT'  do |str|
+        res = str.split(' ')
+        res[1] = @@skypeApi.user(res[1]) if res[1]
+        res
+      end
+      #?
+      def getConfParticipant n
+        str = sendGet "CONF_PARTICIPANT #{n}"
+        array = self::V2O[:ConfParticipant].call str
+        array.unshift n.to_s
+        array
+      end
+      
+      getter :VMDuration, 'VM_DURATION' do |str|
+        str.to_i
+      end
+      getter :VMAllowedDuration, 'VM_ALLOWED_DURATION' do |str|
+        str.to_i
+      end
+      
+      getter :Rate, 'RATE' do |str|
+        str.to_i
+      end
+      getter :RateCurrency, 'RATE_CURRENCY'
+      getter :RatePrecision, 'RATE_PRECISION' do |str|
+        str.to_f #?
+      end
+      
+      getter :Input, 'INPUT'
+      getter :Output, 'OUTPUT'
+      getter :CaptureMic, 'CAPTURE_MIC'
+      getter :VAAInputStatus, 'VAA_INPUT_STATUS' do |str|
+        str._flag
+      end
+            
+      getter :ForwardedBy, 'FORWARDED_BY'
+      getter :TransferActive, 'TRANSFER_ACTIVE' do |str|
+        str._flag
+      end
+      getter :TransferStatus, 'TRANSFER_STATUS'
+      getter :TransferredBy, 'TRANSFERRED_BY'
+      getter :TransferredTo, 'TRANSFERRED_TO'
+
+      notice :CanTransffer, 'CAN_TRANSFER'  do |str|
+        res = str.split ' '
+        res[0] = @@skypeApi.user res[0]
+        res[1] = res[1]._flag
+        res
+      end
+      def getCanTransfer user
+        res = sendGet "CAN_TRANSFER #{user}"
+        V2O[:CanTransffer].call(user.to_s + ' ' + res)
+      end
+            
+      getter :Seen, "SEEN" do |str|
+        str._flag
+      end
+      
+      #Notify?
+      #getter :DTMF, "DTMF" do |str|
+      #  str.to_i
+      #end
+      #getter :JoinConference, "JOIN_CONFERENCE"
+      #getter :StartVideoSend, "START_VIDEO_SEND"
+      #getter :StopVideoSend, "STOP_VIDEO_SEND"
+      #getter :StartVideoReceive, "START_VIDEO_RECEIVE"
+      #getter :StopVideoReceive, "STOP_VIDEO_RECEIVE"
+      
+      def setSeen
+        sendSet "SEEN"
+      end
+      
+      def setStatus s
+        sendSet "STATUS", s
+      end
+      
+      def setStatusOnHold
+        setStatus "ONHOLD"
+      end
+      
+      def setStatusInprogress
+        setStatus "INPROGRESS"
+      end
+      
+      def setStatusFinished
+        setStatus "FINISHED"
+      end
+      
+      def setDTMF num
+        sendSet "DTMF #{num}"
+      end
+      
+      def setJoinConference call
+        sendSet "JOIN_CONFERENCE", masterID.to_s
+      end
+      
+      def setStartVideoSend
+        sendSet "START_VIDEO_SEND"
+      end
+      
+      def setStopVideoSend
+        sendSet "STOP_VIDEO_SEND"
+      end
+      
+      def setStartVideoReceive
+        sendSet "START_VIDEO_RECEIVE"
+      end
+      
+      def setStopVideoReceive
+        sendSet "STOP_VIDEO_RECEIVE"
+      end
+      
+      def answer
+        sendAlter "ANSWER"
+      end
+      
+      def hold
+        sendAlter "HOLD"
+      end
+      
+      def resume
+        sendAlter "RESUME"
+      end
+      
+      def hangup
+        sendAlter "HANGUP"
+      end
+      
+      def end val=''
+        sendAlter "END", val  
+      end
+      
+      def dtmf num
+        sendAlter "DTMF", num
+      end
+      
+      def transfer *users
+        sendAlter "TRANSFER", users.join(', ')
+      end
+      
+      def joinConference call
+        sendAlter "JOIN_CONFERENCE", call.to_s
+      end
+      
+      def startVideoSend
+        sendAlter "START_VIDEO_SEND"
+      end
+
+      def stopVideoSend
+        sendAlter "STOP_VIDEO_SEND"
+      end
+      
+      def startVideoReceive
+        sendAlter "START_VIDEO_RECEIVE"
+      end
+      
+      def stopVideoReceive
+        sendAlter"STOP_VIDEO_RECEIVE"
+      end
+      
+      def setInput arg
+        sendAlter "SET_INPUT", arg
+      end
+      
+      def setOutput arg
+        sendAlter "SET_INPUT", arg
+      end
+      
+      def setCaptureMic arg
+        sendAlter "SET_CAPUTURE_MIC", arg
+      end
+      
+      
+      def alter value
+        sendOne "ALTER CALL #{@id} #{value}","ALTER CALL #{@id}"
+      end
+    end
+  end
+end