ruby_onvif_client 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a4ea5d47b7c0f188430173401d43c90c576fcc48
+  data.tar.gz: 070b68e1ef2e54093147fc3b32a220003ac85c4c
+SHA512:
+  metadata.gz: 49aa588d66590b7b98f28f0bd793619d89f144a5da078f7d132a27d7403c3b924f3ae74e5e49df71cc9e770cef943b66f8933e611f86c344c1010ff5a05cb0d1
+  data.tar.gz: 9ab55c46c26c1c379e607d42cc79cf48796e4475d4d71463c466dff3e5ad2e8de95864e1cf7f0b0a0f717d7ee1f457b5d50feb3d634ced117a35a583dadb43b5

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+gemspec
+

data/lib/ruby_onvif_client/action.rb

@@ -0,0 +1,31 @@
+require_relative 'message'
+
+module ONVIF
+    class Action
+        def initialize client
+            @client = client
+        end
+        
+        def send_message message
+            @client.send message.to_s do |success, result|
+                yield success, result
+            end
+        end
+
+        def callback cb, *args
+            return if cb.class != Proc
+            cb.call *args
+        end
+
+        def value xml_doc, xpath
+            node = xml_doc.at_xpath(xpath)
+            return node.content unless node.nil?
+            ''
+        end
+        def attribute xml_doc, xpath
+            node = xml_doc[xpath]
+            return node unless node.nil?
+            ''
+        end
+    end
+end

data/lib/ruby_onvif_client/client.rb

@@ -0,0 +1,44 @@
+require "em-http"
+require "nokogiri"
+require "nori"
+
+module ONVIF
+    class Client
+        def initialize options
+            @options = {
+                connect_timeout: 5,
+            }.merge(options)
+        end
+
+        def send data
+            puts "send data to #{@options} ", data 
+            http_options = {
+                connect_timeout: @options[:connect_timeout]
+            }
+            request_options = {
+                body: data,
+            }
+            http = EventMachine::HttpRequest.new(
+                @options[:address], 
+                http_options
+            ).post(request_options)
+            http.errback { yield false, {} }
+            http.callback do
+                puts "========================="
+                puts "receive message =>", http.response
+                puts "========================="
+                if http.response_header.status != 200
+                    yield false, {header: http.response_header}
+                else
+                    #nori = Nori.new(:strip_namespaces => true)
+                    yield true, {
+                        header: http.response_header,
+                        #content: nori.parse(http.response)
+                        content: http.response
+                    }
+                end
+            end
+        end
+    end
+end
+

data/lib/ruby_onvif_client/device_discovery.rb

@@ -0,0 +1,36 @@
+require_relative 'path.rb'
+require "uri"
+require "ws_discovery"
+
+module ONVIF
+    class DeviceDiscovery
+        def self.start options = {}
+            DeviceDiscovery.new.start(options) do |devices|
+                yield devices
+            end
+        end
+
+        def start options
+            @options = {
+            }.merge(options)
+            searcher = WSDiscovery.search(
+                env_namespaces: { 
+                    "xmlns:dn" => "http://www.onvif.org/ver10/network/wsdl"
+                }, 
+                types: "dn:NetworkVideoTransmitter"
+            )
+            searcher.discovery_responses.subscribe do |notification|
+                device = {
+                    ep_address: notification[:probe_matches][:probe_match][:endpoint_reference][:address],
+                    types: notification[:probe_matches][:probe_match][:types],
+                    device_ip: URI(notification[:probe_matches][:probe_match][:x_addrs]).host,
+                    device_service_address: notification[:probe_matches][:probe_match][:x_addrs],
+                    scopes: notification[:probe_matches][:probe_match][:scopes].split(' '),
+                    metadata_version: notification[:probe_matches][:probe_match][:metadata_version]
+                }
+                yield device
+            end
+        end
+    end
+end
+

data/lib/ruby_onvif_client/device_management/get_capabilities.rb

@@ -0,0 +1,118 @@
+require_relative '../action'
+
+module ONVIF
+    module DeviceManagementAction
+        class GetCapabilities < Action
+            # options 的结构   <!--0 or more-->
+            # [{
+            #   Category: "All", //nil, 'All', 'Analytics', 'Device', 'Events', 'Imaging', 'Media', 'PTZ'  
+            #              <!--0 or more-->
+            # }]
+            def run options, cb
+                message = Message.new
+                message.body =  ->(xml) do
+                    xml.wsdl(:GetCapabilities) do
+                        unless options.nil?
+                            options.each do |option|
+                                xml.wsdl :Category, option["Category"]
+                            end
+                        end
+                    end
+                end
+                send_message message do |success, result|
+                    if success
+                        xml_doc = Nokogiri::XML(result[:content])
+                        xml_analytics = xml_doc.at_xpath('//tt:Analytics')
+                        xml_device = xml_doc.at_xpath('//tt:Device')
+                        xml_events = xml_doc.at_xpath('//tt:Events')
+                        xml_imaging = xml_doc.at_xpath('//tt:Imaging')
+                        xml_media = xml_doc.xpath('//tt:Media')
+                        xml_ptz = xml_doc.xpath('//tt:PTZ')
+                        success_result = {}
+                        success_result["analytics"] = _get_analytics(xml_analytics) unless xml_analytics.nil?
+                        success_result["device"] = _get_device(xml_device) unless xml_device.nil?
+                        success_result["events"] = _get_events(xml_events) unless xml_events.nil?
+                        success_result["imaging"] = _get_imaging(xml_imaging) unless xml_imaging.nil?
+                        success_result["media"] = _get_media(xml_media) unless xml_media.nil?
+                        success_result["ptz"] = _get_ptz(xml_ptz) unless xml_ptz.nil?
+                        callback cb, success, success_result
+                    else
+                        callback cb, success, result
+                    end
+                end
+            end
+
+            def _get_analytics xml_analytics
+                {
+                    x_addr: value(xml_analytics, '//tt:XAddr'),
+                    rule_support: value(xml_analytics, '//tt:RuleSupport'),
+                    ams: value(xml_analytics, '//tt:AnalyticsModuleSupport')
+                }
+            end
+
+            def _get_device xml_device
+                network_keys = ["IPFilter", "ZeroConfiguration", "IPVersion6", "DynDNS", "Dot11Configuration", 
+                    "Dot1XConfigurations", "HostnameFromDHCP", "NTP", "DHCPv6"]
+                system_keys = ["DiscoveryResolve", "DiscoveryBye", "RemoteDiscovery", "SystemBackup", "SystemLogging",
+                    "FirmwareUpgrade", "HttpFirmwareUpgrade", "HttpSystemBackup", "HttpSystemLogging", "HttpSupportInformation"]
+                security_keys = ["TLS1.0", "TLS1.1", "TLS1.2", "OnboardKeyGeneration", "AccessPolicyConfig", 
+                    "DefaultAccessPolicy", "Dot1X", "RemoteUserHandling", "X.509Token", "SAMLToken", "KerberosToken", 
+                    "UsernameToken", "HttpDigest", "RELToken", "SupportedEAPMethods"]
+                network = {}; system = {}; security = {}
+                network_keys.each do |key|
+                    network[key.underscore] = value(xml_device, '//tt:' + key) unless value(xml_device, '//tt:' + key) == ''
+                end
+                system_keys.each do |key|
+                    system[key.underscore] = value(xml_device, '//tt:' + key) unless value(xml_device, '//tt:' + key) == ''
+                end
+                security_keys.each do |key|
+                    security[key.underscore] = value(xml_device, '//tt:' + key) unless value(xml_device, '//tt:' + key) == ''
+                end
+                return {
+                    x_addr: value(xml_device, '//tt:XAddr'),
+                    network: network,
+                    system: system,
+                    io: {
+                        input_connectors: value(xml_device, '//tt:InputConnectors'),
+                        relay_outputs: value(xml_device, '//tt:RelayOutputs'),
+                        extension: ""
+                    },
+                    security: security
+                }
+            end
+
+            def _get_events xml_events
+                {
+                    x_addr: value(xml_events, '//tt:XAddr'),
+                    wssubscription_policy_support: value(xml_events, '//tt:WSSubscriptionPolicySupport'),
+                    wspull_point_support: value(xml_events, '//tt:WSPullPointSupport'),
+                    wspsmis: value(xml_events, '//tt:WSPausableSubscriptionManagerInterfaceSupport')
+                }
+            end
+
+            def _get_imaging xml_imaging
+                {
+                    x_addr: value(xml_imaging, '//tt:XAddr')
+                }
+            end
+
+            def _get_media xml_media
+                {
+                    x_addr: value(xml_media, '//tt:XAddr'),
+                    streaming_capabilities: {
+                        rtp_multicast: value(xml_media, '//tt:RTPMulticast'),
+                        rtp_tcp: value(xml_media, '//tt:RTPMulticast'),
+                        rtp_rtsp_tcp: value(xml_media, '//tt:RTP_RTSP_TCP'),
+                        extension: ""
+                    },
+                    extension: ""
+                }
+            end
+
+            def _get_ptz xml_ptz
+                {x_addr: value(xml_ptz, '//tt:XAddr')}
+            end
+        end
+    end
+end
+

data/lib/ruby_onvif_client/device_management/get_device_information.rb

@@ -0,0 +1,30 @@
+require_relative '../action'
+
+module ONVIF
+    module DeviceManagementAction
+        class GetDeviceInformation < Action
+            def run cb
+                message = Message.new
+                message.body =  ->(xml) do
+                    xml.wsdl(:GetDeviceInformation)
+                end
+                send_message message do |success, result|
+                    if success
+                        xml_doc = Nokogiri::XML(result[:content])
+                        info = {
+                            mf: value(xml_doc, '//tds:Manufacturer'),
+                            model: value(xml_doc, '//tds:Model'),
+                            firmware_version: value(xml_doc, '//tds:FirmwareVersion'),
+                            serial_number: value(xml_doc, '//tds:SerialNumber'),
+                            hardware_id: value(xml_doc, '//tds:HardwareId')
+                        }
+                        callback cb, success, info
+                    else
+                        callback cb, success, result
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/ruby_onvif_client/device_management/get_network_interfaces.rb

@@ -0,0 +1,131 @@
+require_relative '../action'
+
+module ONVIF
+    module DeviceManagementAction
+        class GetNetworkInterfaces < Action
+            def run cb
+                message = Message.new
+                message.body =  ->(xml) do
+                    xml.wsdl(:GetNetworkInterfaces)
+                end
+                send_message message do |success, result|
+                    if success
+                        xml_doc_main = Nokogiri::XML(result[:content])
+                        interfaces = []
+                        xml_doc_main.xpath('//tds:NetworkInterfaces').each do |xml_doc|
+                            xml_info = xml_doc.at_xpath('tt:Info')
+                            xml_link = xml_doc.at_xpath('tt:Link')
+                            xml_ipv4 = xml_doc.at_xpath('tt:IPv4')
+                            xml_ipv6 = xml_doc.at_xpath('tt:IPv6')
+                            success_result = {
+                                token: attribute(xml_doc, "token"),
+                                enabled: value(xml_doc, "tt:Enabled")
+                            }
+                            success_result["info"] = _get_info(xml_info) unless xml_info.nil?
+                            success_result["link"] = _get_link(xml_link) unless xml_link.nil?
+                            success_result["ipv4"] = _get_ipv_four(xml_ipv4) unless xml_ipv4.nil?
+                            success_result["ipv6"] = _get_ipv_six(xml_ipv6) unless xml_ipv6.nil?
+                            interfaces << success_result
+                        end
+                        callback cb, success, interfaces
+                    else
+                        callback cb, success, result
+                    end
+                end
+            end
+
+            def _get_info xml_info
+                {
+                    name: value(xml_info, 'tt:Name'),
+                    hw_address: value(xml_info, 'tt:HwAddress'),
+                    mtu: value(xml_info, 'tt:MTU')
+                }
+            end
+
+            def _get_link xml_link
+                admin_xml_doc = xml_link.at_xpath('tt:AdminSettings')
+                oper_xml_doc = xml_link.at_xpath('tt:OperSettings')
+                link = {}
+                unless xml_doc.nil?
+                    link["admin_settings"] = {
+                        auto_negotiation: value(admin_xml_doc, "tt:AutoNegotiation"),
+                        speed: value(admin_xml_doc, "tt:Speed"),
+                        duplex: value(admin_xml_doc, "tt:Duplex")
+                    }
+                end
+                unless oper_xml_doc.nil?
+                    link["oper_settings"] = {
+                        auto_negotiation: value(oper_xml_doc, "tt:AutoNegotiation"),
+                        speed: value(oper_xml_doc, "tt:Speed"),
+                        duplex: value(oper_xml_doc, "tt:Duplex")
+                    }
+                end
+                link["interface_type"] = value(xml_link, "tt:InterfaceType") unless xml_link.at_xpath('tt:InterfaceType')
+                return link
+            end
+
+            def _get_ipv_four xml_ipv_four
+                puts xml_ipv_four
+                ipv_four = {enabled: value(xml_ipv_four, 'tt:Enabled')}
+                manual = []; config = {}
+                link_local = xml_ipv_four.xpath('tt:Config/tt:LinkLocal')
+                form_dhcp = xml_ipv_four.xpath('tt:Config/tt:FromDHCP')
+                xml_ipv_four.xpath('tt:Config//tt:Manual').each do |node|
+                    manual << {
+                        address: value(node, "tt:Address"),
+                        prefix_length: value(node, "tt:PrefixLength")
+                    }
+                end
+                config["manual"] = manual
+                config["link_local"] = {
+                    address: value(link_local, "tt:Address"),
+                    prefix_length: value(link_local, "tt:PrefixLength")
+                }
+                config["form_dhcp"] = {
+                    address: value(form_dhcp, "tt:Address"),
+                    prefix_length: value(form_dhcp, "tt:PrefixLength")
+                }
+                config["dhcp"] = value(xml_ipv_four, "tt:Config//tt:DHCP")
+                ipv_four["config"] = config
+                return ipv_four
+            end
+
+            def _get_ipv_six xml_ipv_six
+                ipv_six = {enabled: value(xml_ipv_six, 'tt:Enabled')}
+                config = {}; manual = []; link_local = []; form_dhcp = []; form_ra = []
+                xml_ipv_six.xpath('tt:Config/tt:Manual').each do |node|
+                    manual << {
+                        address: value(node, "tt:Address"),
+                        prefix_length: value(node, "tt:PrefixLength")
+                    }
+                end
+                xml_ipv_six.xpath('tt:Config/tt:LinkLocal').each do |node|
+                    link_local << {
+                        address: value(node, "tt:Address"),
+                        prefix_length: value(node, "tt:PrefixLength")
+                    }
+                end
+                xml_ipv_six.xpath('tt:Config/tt:FromDHCP').each do |node|
+                    form_dhcp << {
+                        address: value(node, "tt:Address"),
+                        prefix_length: value(node, "tt:PrefixLength")
+                    }
+                end
+                xml_ipv_six.xpath('tt:Config/tt:FromRA').each do |node|
+                    form_ra << {
+                        address: value(node, "tt:Address"),
+                        prefix_length: value(node, "tt:PrefixLength")
+                    }
+                end
+                config["manual"] = manual
+                config["link_local"] = link_local
+                config["form_dhcp"] = form_dhcp
+                config["form_ra"] = form_ra
+                config["ara"] = value(xml_ipv_six, "tt:AcceptRouterAdvert")
+                config["dhcp"] = value(xml_ipv_six, "tt:DHCP")
+                ipv_six["config"] = config
+                return ipv_six
+            end
+        end
+    end
+end

data/lib/ruby_onvif_client/device_management/get_network_protocols.rb

@@ -0,0 +1,32 @@
+require_relative '../action'
+
+module ONVIF
+    module DeviceManagementAction
+        class GetNetworkProtocols < Action
+            def run cb
+                message = Message.new
+                message.body =  ->(xml) do
+                    xml.wsdl(:GetNetworkProtocols)
+                end
+                send_message message do |success, result|
+                    if success
+                        xml_doc = Nokogiri::XML(result[:content])
+                        network = []
+                        xml_doc.xpath('//tds:NetworkProtocols').each do |node|
+                            network << {
+                                name: value(node, 'tt:Name'),
+                                enabled: value(node, 'tt:Enabled'),
+                                port: value(node, 'tt:Port'),
+                                extension: value(node, 'tt:Extension')
+                            }
+                        end
+
+                        callback cb, success, network
+                    else
+                        callback cb, success, result
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/ruby_onvif_client/device_management/get_system_date_and_time.rb

@@ -0,0 +1,60 @@
+require_relative '../action'
+
+module ONVIF
+    module DeviceManagementAction
+        class GetSystemDateAndTime < Action
+            def run cb
+                message = Message.new
+                message.body =  ->(xml) do
+                    xml.wsdl(:GetSystemDateAndTime)
+                end
+                send_message message do |success, result|
+                    if success
+                        xml_doc = Nokogiri::XML(result[:content])
+                        xml_utc = xml_doc.xpath('//tt:UTCDateTime')
+                        xml_local = xml_doc.xpath('//tt:LocalDateTime')
+                        utc_data_time = {
+                            time: {
+                                hour: value(xml_utc, '//tt:Hour'),
+                                minute: value(xml_utc, '//tt:Minute'),
+                                second: value(xml_utc, '//tt:Second')
+                            },
+                            date: {
+                                year: value(xml_utc, '//tt:Year'),
+                                month: value(xml_utc, '//tt:Month'),
+                                day: value(xml_utc, '//tt:Day')
+                            }
+                        }
+                        local_date_time = {
+                            time: {
+                                hour: value(xml_local, '//tt:Hour'),
+                                minute: value(xml_local, '//tt:Minute'),
+                                second: value(xml_local, '//tt:Second')
+                            },
+                            date: {
+                                year: value(xml_local, '//tt:Year'),
+                                month: value(xml_local, '//tt:Month'),
+                                day: value(xml_local, '//tt:Day')
+                            }
+                        }
+                        date_time = {
+                            date_time_type: value(xml_doc, '//tt:DateTimeType'),
+                            daylight_savings: value(xml_doc, '//tt:DaylightSavings'),
+                            time_zone: {
+                                tz: value(xml_doc, '//tt:TZ'),
+                            },
+                            extension: value(xml_doc, '//tt:Extension')
+                        }
+                        xml_utc_time = xml_doc.at_xpath('//tt:UTCDateTime')
+                        xml_local_time = xml_doc.at_xpath('//tt:LocalDateTime')
+                        date_time["utc_date_time"] = utc_data_time unless xml_utc_time.nil?
+                        date_time["local_date_time"] = local_date_time unl unless xml_local_time.nil?
+                        callback cb, success, date_time
+                    else
+                        callback cb, success, result
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/ruby_onvif_client/device_management/get_users.rb

@@ -0,0 +1,32 @@
+require_relative '../action'
+
+module ONVIF
+    module DeviceManagementAction
+        class GetUsers < Action
+            def run cb
+                message = Message.new
+                message.body =  ->(xml) do
+                    xml.wsdl(:GetUsers)
+                end
+                send_message message do |success, result|
+                    if success
+                        xml_doc = Nokogiri::XML(result[:content])
+                        users = []
+                        xml_doc.xpath('//tds:User').each do |node|
+                            users << {
+                                name: value(node, 'tt:Username'),
+                                password: value(node, 'tt:Password'),
+                                user_level: value(node, 'tt:UserLevel')
+                            }
+                        end
+
+                        callback cb, success, users
+                    else
+                        callback cb, success, result
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/ruby_onvif_client/device_management/set_network_interfaces.rb

@@ -0,0 +1,83 @@
+require_relative '../action'
+
+module ONVIF
+    module DeviceManagementAction
+        class SetNetworkInterfaces < Action
+            # network_interface 的结构
+            # {
+            #   interface_token: 'xxxxxx',  // name [string]
+            #   nwif:{ // #NetworkInterface 
+            #       enabled: true,   //true, false  [boolean]
+            #       link: {
+            #           auto_negotiation: true,  //true, false [boolean]
+            #           speed: 3,        // [int]
+            #           duplex: 'Full'   //'Full', 'Half' 
+            #       }
+            #       mtu: 2,   // [int]
+            #       ipv4: {
+            #           enabled: true, //true, false [boolean]
+            #           manual: [{
+            #               address: "xxx.xxx.xxx.xxx", // [IPv4Address]
+            #               prefix_length: 22 // [int]
+            #           }],
+            #           dhcp: true //true, false [boolean]
+            #       },
+            #       ipv6: {
+            #           enabled: true, //true, false [boolean]
+            #           ara: false//true, false  #AcceptRouterAdvert    [boolean]
+            #           manual: [{
+            #               address: "xxx.xxx.xxx.xxx", // [IPv4Address]
+            #               prefix_length: 22 // [int]
+            #           }],
+            #           dhcp: true //true, false [boolean]
+            #       }
+            #   }
+            # }
+            def run network_interface, cb
+                message = Message.new namespaces: {:'xmlns:sch' => 'http://www.onvif.org/ver10/schema'}
+                message.body =  ->(xml) do
+                    xml.wsdl(:SetNetworkInterfaces) do
+                        xml.wsdl :InterfaceToken, network_interface["interface_token"]
+                        xml.wsdl :NetworkInterface do
+                            xml.sch :Enabled, network_interface["nwif"]["enabled"]
+                            xml.sch :Link do
+                                xml.sch :AutoNegotiation, network_interface["nwif"]["link"]["auto_negotiation"]
+                                xml.sch :Speed, network_interface["nwif"]["link"]["speed"]
+                                xml.sch :Duplex, network_interface["nwif"]["link"]["duplex"]
+                            end
+                            xml.sch :MTU, network_interface["nwif"]["mtu"]
+                            xml.sch :IPv4 do
+                                xml.sch :Enabled, network_interface["nwif"]["ipv4"]["enabled"]
+                                network_interface["nwif"]["ipv4"]["manual"].each do |manual|
+                                    xml.sch :Manual do
+                                        xml.sch :Address, manual["address"]
+                                        xml.sch :PrefixLength, manual["prefix_length"]
+                                    end
+                                end
+                                xml.sch :DHCP, network_interface["nwif"]["ipv4"]["dhcp"]
+                            end
+                            xml.sch :IPv6 do
+                                xml.sch :Enabled, network_interface["nwif"]["ipv6"]["enabled"]
+                                xml.sch :AcceptRouterAdvert, network_interface["nwif"]["ipv6"]["ara"]
+                                network_interface["nwif"]["ipv6"]["manual"].each do |manual|
+                                    xml.sch :Manual do
+                                        xml.sch :Address, manual["address"]
+                                        xml.sch :PrefixLength, manual["prefix_length"]
+                                    end
+                                end
+                                xml.sch :DHCP, network_interface["nwif"]["ipv6"]["dhcp"]
+                            end
+
+                        end
+                        xml.wsdl :Extension do
+                        end
+                    end
+                end
+                send_message message do |success, result|
+                    #????
+                    callback cb, success, result
+                end
+            end
+        end
+    end
+end

data/lib/ruby_onvif_client/device_management/set_system_date_and_time.rb

@@ -0,0 +1,48 @@
+require_relative '../action'
+
+module ONVIF
+    module DeviceManagementAction
+        class SetSystemDateAndTime < Action
+            # system_date_time 的结构
+            # {
+            #   type: 'Manual', //  'Manual', 'NTP'
+            #   ds: false // DaylightSavings [booblean]
+            #   time_zone_tz: 'xxxxx'// string TimeZone -> TZ  [token]
+            #   year: 2013 // int
+            #   month: 6   // int 1 to 12
+            #   day: 26 // int 1 to 31
+            #   hour: 5  // int 0 to 23
+            #   minute: 31 //int 0 to 59
+            #   second: 44 //int 0 to 61 (typically 59)
+            # }
+            def run system_date_time, cb
+                message = Message.new namespaces: {:'xmlns:sch' => 'http://www.onvif.org/ver10/schema'}
+                message.body =  ->(xml) do
+                    xml.wsdl(:SetSystemDateAndTime) do
+                        xml.wsdl :DateTimeType, system_date_time["type"]
+                        xml.wsdl :DaylightSavings, system_date_time["ds"]
+                        xml.wsdl(:TimeZone) do
+                            xml.sch :TZ, system_date_time["time_zone_tz"]
+                        end
+                        xml.wsdl(:TimeZone) do
+                            xml.sch :Time do
+                                xml.sch :Hour, system_date_time["hour"]
+                                xml.sch :Minute, system_date_time["minute"]
+                                xml.sch :Second, system_date_time["second"]
+                            end
+                            xml.sch :Date do
+                                xml.sch :Year, system_date_time["year"]
+                                xml.sch :Month, system_date_time["month"]
+                                xml.sch :Day, system_date_time["day"]
+                            end
+                        end
+                    end
+                end
+                send_message message do |success, result|
+                    #????
+                    callback cb, success, result
+                end
+            end
+        end
+    end
+end