SkypeR 0.0.8 → 0.0.9

data/lib/skyper/parser.rb

@@ -14,7 +14,8 @@ module SkypeR
     class Identifier < Yaparc::AbstractParser
       def initialize
         @parser = lambda do
-          Yaparc::Tokenize.new(Yaparc::Ident.new)
+#          Yaparc::Tokenize.new(Yaparc::Ident.new)
+          Yaparc::Regex.new(/\A[0-9a-zA-Z_]+/)
         end
       end
     end
@@ -50,7 +51,7 @@ module SkypeR
     class CommandID < Yaparc::AbstractParser
       def initialize
         @parser = lambda do
-          Yaparc::Tokenize.new(Yaparc::Regex.new(/#[A-Z0-9]+/))
+          Yaparc::Tokenize.new(Yaparc::Regex.new(/\A#[A-Z0-9]+/))
 #          Yaparc::Token.new(Yaparc::Regex.new(/#[A-Z0-9]+/))
         end
       end
@@ -60,8 +61,16 @@ module SkypeR
     class ChatID < Yaparc::AbstractParser
       def initialize
         @parser = lambda do
-          Yaparc::Tokenize.new(Yaparc::Regex.new(/#[A-Za-z]*\/\$[A-Za-z]*;[0-9]*/))
-#          Yaparc::Token.new(Yaparc::Regex.new(/#[A-Za-z]*\/\$[A-Za-z]*;[0-9]*/))
+          # #tk3adapter/$akimichi_tatsukawa;309cfdf0927d827b
+          Yaparc::Seq.new(Yaparc::Literal.new('#'),
+                          Identifier.new, 
+                          Yaparc::Literal.new('/$'),
+                          Identifier.new, 
+                          Yaparc::Literal.new(';'),
+                          Yaparc::Regex.new(/\A\w+/)) do |_,sender,_,receiver,_,identifier|
+            "##{sender}/$#{receiver};#{identifier}"
+#          Yaparc::Tokenize.new(Yaparc::Regex.new(/#[A-Za-z]*\/\$[A-Za-z]*;[0-9]*/))
+          end
         end
       end
     end

data/lib/skyper/response.rb

@@ -6,7 +6,7 @@ require "logger"
 
 
 =begin
-(insert-image-file "~/develop/ruby/skyper/docs/parser.png")
+
 =end
 
 module SkypeR
@@ -46,10 +46,12 @@ module SkypeR
       def initialize
         @parser = lambda do
           Yaparc::Seq.new(Yaparc::Symbol.new("USER"),
-                                Yaparc::Identifier.new,
-                                SkypeR::Parser::UserProperty.new,
-                                AnyValue.new) do |_,identifier,property, value|
-            {:identifier => identifier, :property =>  property, :value => value}
+                          Yaparc::Identifier.new,
+                          SkypeR::Parser::UserProperty.new,
+                          AnyValue.new) do |_,identifier,property, value|
+            #{:identifier => identifier, :property =>  property, :value => value}
+            SkypeR::Object::User.new(Hash[:handle => identifier, :"#{property}" => value])
+                                          
           end
         end
       end
@@ -99,15 +101,15 @@ module SkypeR
       def initialize
         @parser = lambda do
           Yaparc::Seq.new(Yaparc::Symbol.new("CHAT"),
-                                ChatID.new,
-                                Yaparc::Symbol.new("CHATMESSAGES"),
-                                Yaparc::Many.new(
-                                                       Yaparc::Seq.new(Yaparc::Symbol.new(','),
-                                                                             Target.new) do |_, target|
-                                         target
-                                       end
-                                       )
-                        )
+                          SkypeR::Parser::ChatID.new,
+                          Yaparc::Symbol.new("CHATMESSAGES"),
+                          Yaparc::Many.new(
+                                           Yaparc::Seq.new(Yaparc::Symbol.new(','),
+                                                           Target.new) do |_, target|
+                                             target
+                                           end
+                                           )
+                          )
         end
       end
     end
@@ -258,20 +260,44 @@ module SkypeR
 
     # <chat_create_response> := CHAT <chat_id> STATUS <value>
     class ChatCreateResponse < ResponseBase
-      def initialize
+      attr_accessor :chat_object
+
+      def initialize(chat_object)
+        @chat_object = chat_object
         @parser = lambda do
           Yaparc::Seq.new(
+                          CommandID.new,
                           Yaparc::Symbol.new("CHAT"),
-                          CallId.new,
+                          SkypeR::Parser::ChatID.new,
                           Yaparc::Symbol.new("STATUS"),
                           AnyValue.new
-                          ) do |_,call_id,_,value|
-            {:call_id => call_id, :value => value}
+                          ) do |command_id,_,chat_id,_,status|
+            @chat_object.name = chat_id
+            @chat_object.status = status
+            @chat_object
+            #SkypeR::Object::Chat.new(Hash[:name => chat_id, :status => status]
           end
         end
       end
     end
 
 
+    #  <chat_message_response> := CHATMESSAGE <id> STATUS SENDING
+    class ChatMessageResponse < ResponseBase
+      def initialize
+        @parser = lambda do
+          Yaparc::Seq.new(
+                          Yaparc::Symbol.new("CHATMESSAGE"),
+                          CallId.new,
+                          Yaparc::Symbol.new("STATUS"),
+                          Yaparc::Symbol.new("SENDING")
+                          ) do |_,call_id,_,_|
+            #{:call_id => call_id}
+            SkypeR::Object::ChatMessage.new(Hash[:from_handle => call_id, :status => :sending])
+          end
+        end
+      end
+    end
+
   end # of Parser
 end # of Skyper

data/lib/skyper/service.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-#require 'uuidtools.rb'
 require 'uuidtools'
 require 'rbus.rb'
 require 'thread.rb'
@@ -10,6 +9,12 @@ module SkypeR
   module Service
     class Application
       def initialize(name, protocol_num = 5)
+        unless ENV["DBUS_SESSION_BUS_ADDRESS"]
+          output = `dbus-launch --auto-syntax`
+          dbus_session_bus_address, dummy, dbus_session_bus_pid = output.split("\n")
+          ENV["DBUS_SESSION_BUS_ADDRESS"] = dbus_session_bus_address.match(/\ADBUS_SESSION_BUS_ADDRESS='(.*)';\Z/)[1]
+          ENV["DBUS_SESSION_BUS_PID"] = dbus_session_bus_pid.match(/\ADBUS_SESSION_BUS_PID=(.*)*;\Z/)[1]
+        end
         remote_bus = ::RBus.session_bus
         service_name = 'com.Skype.API'
         object_path = "/com/Skype"
@@ -19,30 +24,39 @@ module SkypeR
         @invoked_commands = Hash.new
       end
 
+
+      def execute(command, timeout = 60)
+        
+      end
+
       def invoke(command, timeout = 60)
         begin
           ::Timeout.timeout(timeout) {
             authenticate
-            @invoked_commands[command.command_id] = command.statement
-            @api_object.Invoke("##{command.command_id} #{command.statement}")
+            case result = parse(command)
+            when Yaparc::Result::OK
+              response_parser = result.value[:response_parser]
+              generated_object = result.value[:generated_object]
+              @invoked_commands[command.command_id] = command.statement
+              response_statement = @api_object.Invoke("##{command.command_id} #{command.statement}")
+#              response_parser.parse(response_statement)
+            when Yaparc::Result::Fail
+              raise SkypeR::Exception::ParseError
+            else
+              raise SkypeR::Exception::UnknownError
+            end 
           }
+        rescue SkypeR::Exception::ParseError
+          puts "Parse Error: '#{command.statement}'"
+          []
         rescue ::Timeout::Error
           puts "Connection timeout. Please try again."
         end
       end
 
 
-      def parse(message)
-        case message
-        when CommandMessage
-          command_parser = SkypeR::Parser::CommandStatement.new
-          command_parser.parse(message.statement)
-        when ResponseMessage
-          response_parser = SkypeR::Parser::ResponseCommandStatement.new
-          response_parser.parse(message.statement)
-        else
-          raise
-        end
+      def parse(command_message)
+        command_message.parse
       end
 
       def validate(command)
@@ -80,9 +94,17 @@ module SkypeR
 
       def initialize(statement)
         @statement = statement
-        @command_id = UUID.timestamp_create.to_i
+#        UUID.mac_address = nil
+#        @command_id = UUID.timestamp_create.to_i
+        @command_id = UUID.random_create.to_i
       end
-    end # of Command
+
+      def parse
+        command_parser = SkypeR::Parser::CommandStatement.new
+        command_parser.parse(@statement)
+      end
+
+    end # of CommandMessage
 
 
     class ResponseMessage < MessageBase
@@ -91,6 +113,12 @@ module SkypeR
         @statement = statement
         @response_instance = response_instance
       end
+
+      def parse
+        response_parser = SkypeR::Parser::ResponseCommandStatement.new
+        response_parser.parse(@statement)
+      end
+
     end # Response
 
 #     class Result < Response

data/lib/skyper/service.rb.back

@@ -0,0 +1,127 @@
+require 'rubygems'
+require 'uuidtools'
+require 'rbus.rb'
+require 'thread.rb'
+require 'timeout.rb'
+
+
+module SkypeR
+  module Service
+    class Application
+      def initialize(name, protocol_num = 5)
+        unless ENV["DBUS_SESSION_BUS_ADDRESS"]
+          output = `dbus-launch --auto-syntax`
+          dbus_session_bus_address, dummy, dbus_session_bus_pid = output.split("\n")
+          ENV["DBUS_SESSION_BUS_ADDRESS"] = dbus_session_bus_address.match(/\ADBUS_SESSION_BUS_ADDRESS='(.*)';\Z/)[1]
+          ENV["DBUS_SESSION_BUS_PID"] = dbus_session_bus_pid.match(/\ADBUS_SESSION_BUS_PID=(.*)*;\Z/)[1]
+        end
+        remote_bus = ::RBus.session_bus
+        service_name = 'com.Skype.API'
+        object_path = "/com/Skype"
+        @api_object = remote_bus.get_object(service_name, object_path)
+        @api_object.interface!(service_name)
+        @application_name = name
+        @invoked_commands = Hash.new
+      end
+
+
+      def execute(command, timeout = 60)
+        
+      end
+
+      def invoke(command, timeout = 60)
+        begin
+          ::Timeout.timeout(timeout) {
+            authenticate
+            case result = parse(command)
+            when Yaparc::Result::OK
+              response_parser = result.value[:response_parser]
+              generated_object = result.value[:generated_object]
+              @invoked_commands[command.command_id] = command.statement
+              response_statement = @api_object.Invoke("##{command.command_id} #{command.statement}")
+              response_parser.parse(response_statement)
+            when Yaparc::Result::Fail
+              raise SkypeR::Exception::ParseError
+            else
+              raise SkypeR::Exception::UnknownError
+            end 
+          }
+        rescue ::Timeout::Error
+          puts "Connection timeout. Please try again."
+        end
+      end
+
+
+      def parse(command_message)
+        command_message.parse
+      end
+
+      def validate(command)
+        case result = parse(command)
+        when Yaparc::Result::OK
+          true
+        when Yaparc::Result::Fail
+          false
+        else
+          raise
+        end
+      end
+
+      private
+      def authenticate(protocol_num = 5)
+        result = nil
+        query = Thread.start do
+          name_command = SkypeR::Service::CommandMessage.new("NAME #{@application_name}")
+          result = @api_object.Invoke(name_command.statement)
+          puts result
+          protocol_command = SkypeR::Service::CommandMessage.new("PROTOCOL #{protocol_num}")
+          result = @api_object.Invoke(protocol_command.statement)
+          puts result
+        end
+        query.join
+      end
+    end # of Application
+
+
+    class MessageBase
+      attr_accessor :statement, :command_id
+    end
+
+    class CommandMessage < MessageBase
+
+      def initialize(statement)
+        @statement = statement
+#        UUID.mac_address = nil
+#        @command_id = UUID.timestamp_create.to_i
+        @command_id = UUID.random_create.to_i
+      end
+
+      def parse
+        command_parser = SkypeR::Parser::CommandStatement.new
+        command_parser.parse(@statement)
+      end
+
+    end # of CommandMessage
+
+
+    class ResponseMessage < MessageBase
+      attr_accessor :statement, :response_instance
+      def initialize(statement, response_instance)
+        @statement = statement
+        @response_instance = response_instance
+      end
+
+      def parse
+        response_parser = SkypeR::Parser::ResponseCommandStatement.new
+        response_parser.parse(@statement)
+      end
+
+    end # Response
+
+#     class Result < Response
+#     end
+
+#     class Error < Response
+#     end
+  end
+end

data/lib/skyper/service.rb.org

@@ -0,0 +1,181 @@
+# author: Péter Kiss, Akimichi TATSUKAWA
+
+require 'rubygems'
+require 'uuidtools'
+#require 'rbus.rb'
+require 'thread.rb'
+require 'timeout.rb'
+#require 'dbus'
+
+
+
+module SkypeR
+  #{{Szinkron kommunikációnál ennyi sec-t várunk a DBUS-válaszra
+  TIMEOUT = 15
+  #}}
+  module Service
+    class Application
+      #async [] pufferek
+      attr_accessor :missed_chats,:missed_messages,:connstatus
+ 
+      def initialize(name, protocol_num = 5)
+       
+        @missed_chats = []
+        @missed_messages = []
+        @missed_chats_puff = []
+        @connstatus = []
+        @global_res = []
+ 
+#        remote_bus = ::RBus.session_bus
+#        service_dbus = remote_bus.service('org.freedesktop.DBus')
+        remote_bus = ::DBus.session_bus
+        service_dbus = remote_bus_dbus.request_service("com.Skype.API.Client")
+ 
+        #és elkérjük a skype service-t
+        skype_service_name = 'com.Skype.API'
+        object_path = '/com/Skype'
+        @api_object = remote_bus.get_object(skype_service_name, object_path)
+        
+        #Notify-k kezelése
+        #
+        # << %Gő%@ ezen hív minket befelé
+        @api_object.connect!(:Notify, :member => 'Notify', :type => 'method_call', :path => '/com/Skype/Client', :interface => 'com.Skype.API.Client') {|s|
+            my_arr = s.split()
+# puts s
+            if my_arr.size == 2 and not ((my_arr[0] =~ /#/) == 0)
+              #Státusz üzenet. köszönjük
+              var,value = my_arr
+              #instance_eval("puts 'Status changed #{var}->#{value}' if defined?(@#{var.downcase}) and @#{var.downcase} != '#{value}'")
+# instance_eval("@#{var.downcase}='#{value}'")
+              @connstatus_last = value
+              Thread.exclusive(){ @connstatus << value if @connstatus_last != value} if var == 'CONNSTATUS'
+              return ['']
+            else
+              #hogyha nekünk érkezett vmi id-vel válasz, akkor tároljuk csak le.
+              if( (my_arr[0] =~ /#/) == 0)
+                Thread.exclusive(){@global_res << s}
+              else
+                s.gsub(/CHAT\s([^\s]*)\sACTIVITY_TIMESTAMP\s([0-9]*)/){
+                  chat_id,ts,ts = $1,$2,$3
+                  Thread.exclusive(){ @missed_chats_puff << chat_id }
+                  print 'iC'
+                  return ['']
+                }
+                s.gsub(/CHATMESSAGE\s([0-9]+)\sSTATUS\sRECEIVED/){
+                  msg_id = $1
+                  Thread.exclusive(){
+                    @missed_chats << @missed_chats_puff.delete_at(0)
+                    @missed_messages << msg_id
+                  }
+                  print 'im'
+                  return ['']
+                }
+ 
+                #ezek a kliensen történ%Gő%@ egyéb események hatására érkez%Gő%@ infók, amit nem kezelünk (még)
+                puts s
+                #return ['']
+              end
+            end
+          return ['']
+        }
+        # >> mi ezen kommunikálunk kifelé
+        @api_object.interface!(skype_service_name)
+        @application_name = name
+        # @invoked_commands = Hash.new
+      end
+      # ez itt egy dbus-os service publikálás és hívás.
+      # mivel sikerült m%Gű%@ködésre bírni az RBus-szal ezért erre nincs szükség.
+      def init_callback
+        STDOUT.sync = true
+        remote_bus_dbus = ::DBus.session_bus
+        my_service = remote_bus_dbus.request_service("com.Skype.API.Client")
+        exported_obj = Test.new('/com/Skype/Client')
+        my_service.export(exported_obj)
+        Thread.new do
+          begin
+            main = DBus::Main.new
+            main << remote_bus_dbus
+            main.run
+          rescue Exception => e
+            puts e.message
+            puts "Backtrace:"
+            e.backtrace.each {|line| puts line }
+          end
+         end
+         ms = remote_bus_dbus.service('com.Skype.API.Client')
+         o = ms.object('/com/Skype/Client')
+         o.introspect
+         o.default_iface = 'com.Skype.API.Client'
+         o.Notify 'szevasz'
+      end
+ 
+      # segéd fv. biztonságosan ránéz az aktuális üzenetre és true,ha nekünk jött
+      def not_for_us_thread_safe_sync command_id
+        Thread.exclusive(){
+          @res == nil or (@res.split[0] != "##{command_id}")
+        }
+      end
+ 
+      # segéd fv. biztonságosan ránéz az aktuális üzenetre és true,ha nekünk jött
+      def not_for_us_thread_safe_async command_id
+        Thread.exclusive(){
+          @global_res.empty? or !@global_res.select{|s| s.split[0] == "##{command_id}"}
+        }
+      end
+ 
+      #asynchron message handleing to avoid skype for hang
+      def invoke(command, timeout = TIMEOUT)
+        @global_res = []
+        begin
+          ::Timeout.timeout(timeout) {
+            
+            authenticate
+ 
+            command_string = "##{command.command_id} #{command.statement}"
+            #puts command_string
+            @api_object.Invoke(command_string){|async_result|
+              @res = nil
+              
+              while @res == nil do
+                Thread.pass
+                @res = async_result.dup
+              end
+            }
+            # megvárjuk, amíg jön valami értelmes.
+            # az "" is értelmes, lásd lentebb
+            while not_for_us_thread_safe_sync(command.command_id) do
+              break if @res == ""
+              Thread.pass
+            end
+            return @res if @res != ""
+          }
+          # "" -> ide akkor jutunk, ha asszinkron
+          # visszahívásra várunk ezért most várjuk, hogy
+          # megérkezzék az adat.
+          while not_for_us_thread_safe_async(command.command_id) do
+            #had játszadozzon üzenetküldéssel a skype, ha akar, mégiscsak ez egy asszinkron üzenet..
+            sleep(1)
+ 
+            Thread.pass
+          end
+          Thread.exclusive(){
+            @res = @global_res.select{|s| s.split[0] == "##{command.command_id}"}.shift.dup
+          }
+          return @res
+        rescue ::Timeout::Error
+           print 't' if DEBUG == true
+        end
+      end
+ 
+      def authenticate(protocol_num = 5)
+        result = nil
+        name_command = SkypeR::Service::CommandMessage.new("NAME #{@application_name}")
+        result = @api_object.Invoke(name_command.statement)
+        puts result unless result =~ /PROTOCOL|OK/
+        protocol_command = SkypeR::Service::CommandMessage.new("PROTOCOL #{protocol_num}")
+        result = @api_object.Invoke(protocol_command.statement)
+        puts result unless result =~ /PROTOCOL|OK/
+      end
+    end # of Application
+  end
+end