obsws 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 339b5706222511d0cf272eff7040f45dc5bc1cffdfdc6b6d0cc59ea299c325e1
+  data.tar.gz: 2070c51a27e764297d2555bd958411fd8ee06c49f98bd09fa6144f7fba5790c8
+SHA512:
+  metadata.gz: c80761585030c73bd304de37ead5ea8f5260116f7e2acb6a15549d920695be579c0fc0ffa9f0485569ffd56f4c11b6ca027711eeadb2ecb81c8b9b3016e68396
+  data.tar.gz: 13fc659eb70544b51555cb9f68608927f64671377f550ae78c3d9a83b60de2f42050d17403ae72aeb701525fc15e48a5086d37f05c780b4055a24cfe252bd0a1

data/README.md

@@ -0,0 +1,116 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/onyx-and-iris/voicemeeter-api-ruby/blob/dev/LICENSE)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/plugin-ruby)
+
+# A Ruby wrapper around OBS Studio WebSocket v5.0
+
+## Requirements
+
+-   [OBS Studio](https://obsproject.com/)
+-   [OBS Websocket v5 Plugin](https://github.com/obsproject/obs-websocket/releases/tag/5.0.0)
+    -   With the release of OBS Studio version 28, Websocket plugin is included by default. But it should be manually installed for earlier versions of OBS.
+-   Ruby 3.0 or greater
+
+## `Use`
+
+#### Example `main.rb`
+
+pass `host`, `port` and `password` as keyword arguments.
+
+```ruby
+require_relative "lib/obsws"
+
+def main
+  r_client =
+    OBSWS::Requests::Client.new(
+      host: "localhost",
+      port: 4455,
+      password: "strongpassword"
+    )
+
+  r_client.run do
+    # Toggle the mute state of your Mic input
+    r_client.toggle_input_mute("Mic/Aux")
+  end
+end
+
+main if $0 == __FILE__
+```
+
+### Requests
+
+Method names for requests match the API calls but snake cased. `run` accepts a block that closes the socket once you are done.
+
+example:
+
+```ruby
+r_client.run do
+  # GetVersion
+  resp = r_client.get_version
+
+  # SetCurrentProgramScene
+  r_client.set_current_program_scene("BRB")
+end
+```
+
+For a full list of requests refer to [Requests](https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md#requests)
+
+### Events
+
+Register an observer class and define `on_` methods for events. Method names should match the api event but snake cased.
+
+example:
+
+```ruby
+class Observer
+    def initialize
+        @e_client = OBSWS::Events::Client.new(**kwargs)
+        # register class with the event client
+        @e_client.add_observer(self)
+    end
+
+    # define "on_" event methods.
+    def on_current_program_scene_changed
+        ...
+    end
+    def on_input_mute_state_changed
+        ...
+    end
+    ...
+end
+```
+
+For a full list of events refer to [Events](https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md#events)
+
+### Attributes
+
+For both request responses and event data you may inspect the available attributes using `attrs`.
+
+example:
+
+```ruby
+resp = cl.get_version
+p resp.attrs
+
+def on_scene_created(data):
+    p data.attrs
+```
+
+### Errors
+
+If a request fails an `OBSWSError` will be raised with a status code.
+
+For a full list of status codes refer to [Codes](https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md#requeststatus)
+
+### Tests
+
+To run all tests:
+
+```
+bundle exec rake -v
+```
+
+### Official Documentation
+
+For the full documentation:
+
+-   [OBS Websocket SDK](https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md#obs-websocket-501-protocol)

data/lib/obsws/base.rb

@@ -0,0 +1,117 @@
+require "socket"
+require "websocket/driver"
+require "digest/sha2"
+require "json"
+require "observer"
+require "waitutil"
+
+require_relative "mixin"
+require_relative "error"
+
+module OBSWS
+  class Socket
+    attr_reader :url
+
+    def initialize(url, socket)
+      @url = url
+      @socket = socket
+    end
+
+    def write(s)
+      @socket.write(s)
+    end
+  end
+
+  class Base
+    include Observable
+    include Mixin::OPCodes
+
+    attr_reader :id, :driver, :closed
+
+    def initialize(**kwargs)
+      host = kwargs[:host] || "localhost"
+      port = kwargs[:port] || 4455
+      @password = kwargs[:password] || ""
+      @subs = kwargs[:subs] || 0
+
+      @socket = TCPSocket.new(host, port)
+      @driver =
+        WebSocket::Driver.client(Socket.new("ws://#{host}:#{port}", @socket))
+      @ready = false
+      @closed = false
+      @driver.on :open do |msg|
+        LOGGER.debug("driver socket open")
+        @ready = true
+      end
+      @driver.on :close do |msg|
+        LOGGER.debug("driver socket closed")
+        @closed = true
+      end
+      @driver.on :message do |msg|
+        LOGGER.debug("received [#{msg}] passing to handler")
+        msg_handler(JSON.parse(msg.data, symbolize_names: true))
+      end
+      Thread.new { start_driver }
+      WaitUtil.wait_for_condition(
+        "driver socket ready",
+        delay_sec: 0.01,
+        timeout_sec: 0.5
+      ) { @ready }
+    end
+
+    def start_driver
+      @driver.start
+
+      loop do
+        @driver.parse(@socket.readpartial(4096))
+      rescue EOFError
+        break
+      end
+    end
+
+    def auth_token(salt:, challenge:)
+      Digest::SHA256.base64digest(
+        Digest::SHA256.base64digest(@password + salt) + challenge
+      )
+    end
+
+    def authenticate(auth)
+      token = auth_token(**auth)
+      payload = {
+        op: Mixin::OPCodes::IDENTIFY,
+        d: {
+          rpcVersion: 1,
+          authentication: token,
+          eventSubscriptions: @subs
+        }
+      }
+      @driver.text(JSON.generate(payload))
+    end
+
+    def msg_handler(data)
+      op_code = data[:op]
+      case op_code
+      when Mixin::OPCodes::HELLO
+        authenticate(data[:d][:authentication])
+      when Mixin::OPCodes::IDENTIFIED
+        LOGGER.debug("Authentication successful")
+      when Mixin::OPCodes::EVENT, Mixin::OPCodes::REQUESTRESPONSE
+        changed
+        notify_observers(op_code, data[:d])
+      end
+    end
+
+    def req(id, type_, data = nil)
+      payload = {
+        op: Mixin::OPCodes::REQUEST,
+        d: {
+          requestType: type_,
+          requestId: id
+        }
+      }
+      payload[:d][:requestData] = data if data
+      queued = @driver.text(JSON.generate(payload))
+      LOGGER.debug("request with id #{id} queued? #{queued}")
+    end
+  end
+end

data/lib/obsws/error.rb

@@ -0,0 +1,6 @@
+module OBSWS
+  module Error
+    class OBSWSError < StandardError
+    end
+  end
+end

data/lib/obsws/event.rb

@@ -0,0 +1,92 @@
+require "json"
+
+require_relative "util"
+require_relative "mixin"
+
+module OBSWS
+  module Events
+    module SUBS
+      NONE = 0
+      GENERAL = (1 << 0)
+      CONFIG = (1 << 1)
+      SCENES = (1 << 2)
+      INPUTS = (1 << 3)
+      TRANSITIONS = (1 << 4)
+      FILTERS = (1 << 5)
+      OUTPUTS = (1 << 6)
+      SCENEITEMS = (1 << 7)
+      MEDIAINPUTS = (1 << 8)
+      VENDORS = (1 << 9)
+      UI = (1 << 10)
+
+      def low_volume
+        GENERAL | CONFIG | SCENES | INPUTS | TRANSITIONS | FILTERS | OUTPUTS |
+          SCENEITEMS | MEDIAINPUTS | VENDORS | UI
+      end
+
+      INPUTVOLUMEMETERS = (1 << 16)
+      INPUTACTIVESTATECHANGED = (1 << 17)
+      INPUTSHOWSTATECHANGED = (1 << 18)
+      SCENEITEMTRANSFORMCHANGED = (1 << 19)
+
+      def high_volume
+        INPUTVOLUMEMETERS | INPUTACTIVESTATECHANGED | INPUTSHOWSTATECHANGED |
+          SCENEITEMTRANSFORMCHANGED
+      end
+
+      def all
+        low_volume | high_volume
+      end
+
+      module_function :low_volume, :high_volume, :all
+    end
+
+    module Callbacks
+      include Util
+
+      def add_observer(observer)
+        @observers = [] unless defined?(@observers)
+        observer = [observer] if !observer.respond_to? :each
+        observer.each { |o| @observers.append(o) }
+      end
+
+      def remove_observer(observer)
+        @observers.delete(observer)
+      end
+
+      def notify_observers(event, data)
+        if defined?(@observers)
+          @observers.each do |o|
+            if o.respond_to? "on_#{event.to_snake}"
+              if data.empty?
+                o.send("on_#{event.to_snake}")
+              else
+                o.send("on_#{event.to_snake}", data)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    class Client
+      include Callbacks
+      include Mixin::TearDown
+      include Mixin::OPCodes
+
+      def initialize(**kwargs)
+        kwargs[:subs] = SUBS.low_volume
+        @base_client = Base.new(**kwargs)
+        @base_client.add_observer(self)
+      end
+
+      def update(op_code, data)
+        if op_code == Mixin::OPCodes::EVENT
+          event = data[:eventType]
+          data = data.key?(:eventData) ? data[:eventData] : {}
+          notify_observers(event, Mixin::Data.new(data, data.keys))
+        end
+      end
+    end
+  end
+end

data/lib/obsws/mixin.rb

@@ -0,0 +1,53 @@
+require_relative "util"
+
+module OBSWS
+  module Mixin
+    module Meta
+      include Util
+
+      def make_response_methods(*params)
+        params.each do |param|
+          define_singleton_method(param.to_s.to_snake) { @resp[param] }
+        end
+      end
+    end
+
+    class MetaObject
+      include Mixin::Meta
+
+      def initialize(resp, fields)
+        @resp = resp
+        @fields = fields
+        self.make_response_methods *fields
+      end
+
+      def empty? = @fields.empty?
+
+      def attrs = @fields.map { |f| f.to_s.to_snake }
+    end
+
+    class Response < MetaObject
+    end
+
+    class Data < MetaObject
+    end
+
+    module TearDown
+      def close
+        @base_client.driver.close
+      end
+    end
+
+    module OPCodes
+      HELLO = 0
+      IDENTIFY = 1
+      IDENTIFIED = 2
+      REIDENTIFY = 3
+      EVENT = 5
+      REQUEST = 6
+      REQUESTRESPONSE = 7
+      REQUESTBATCH = 8
+      REQUESTBATCHRESPONSE = 9
+    end
+  end
+end