opentok 4.1.2 → 4.4.0

data/lib/opentok/broadcasts.rb

@@ -1,6 +1,6 @@
 require "opentok/client"
 require "opentok/broadcast"
-
+require "opentok/broadcast_list"
 
 module OpenTok
   # A class for working with OpenTok live streaming broadcasts.
@@ -22,42 +22,88 @@ module OpenTok
     # @param [String] session_id The session ID of the OpenTok session to broadcast.
     #
     # @param [Hash] options A hash defining options for the broadcast.
-    # @option options [Hash] :layout Specify this to assign the initial layout  for the broadcast.
-    #   Valid values for the layout (<code>:type</code>) property are "bestFit" (best fit), "custom" (custom),
-    #   "horizontalPresentation" (horizontal presentation), "pip" (picture-in-picture), and
-    #   "verticalPresentation" (vertical presentation)).
-    #   If you specify a (<code>:custom</code>) layout type, set the (<code>:stylesheet</code>) property of the layout object
-    #   to the stylesheet. (For other layout types, do not set a stylesheet property.)
-    #   If you do not specify an initial layout type, the broadcast stream uses the Best Fit layout type.
+    #
+    # @option options [Hash] :layout Specify this to assign the initial layout type for
+    #   the broadcast. This is a hash containing three keys:
+    #   <code>:type</code>, <code>:stylesheet<code> and <code>:screenshare_type</code>.
+    #   Valid values for <code>:type</code> are "bestFit" (best fit), "custom" (custom),
+    #    "horizontalPresentation" (horizontal presentation),
+    #   "pip" (picture-in-picture), and "verticalPresentation" (vertical presentation)).
+    #   If you specify a "custom" layout type, set the <code>:stylesheet</code> key to the
+    #   stylesheet (CSS). (For other layout types, do not set the <code>:stylesheet</code> key.)
+    #   Valid values for <code>:screenshare_type</code> are "bestFit", "pip",
+    #   "verticalPresentation", "horizontalPresentation". This property is optional.
+    #   If it is specified, then the <code>:type</code> property **must** be set to "bestFit".
+    #   If you do not specify an initial layout type, the broadcast uses the best fit
+    #   layout type.
     #
     # @option options [int] maxDuration
     #   The maximum duration for the broadcast, in seconds. The broadcast will automatically stop when
     #   the maximum duration is reached. You can set the maximum duration to a value from 60 (60 seconds) to 36000 (10 hours).
-    #   The default maximum duration is 2 hours (7200 seconds).
+    #   The default maximum duration is 4 hours (14,400 seconds).
     #
-    # @option options [Hash] outputs
+    # @option options [Hash] outputs (Required)
     #   This object defines the types of broadcast streams you want to start (both HLS and RTMP).
     #   You can include HLS, RTMP, or both as broadcast streams. If you include RTMP streaming,
     #   you can specify up to five target RTMP streams (or just one).
-    #   The (<code>:hls</code>) property is set  to an empty [Hash] object. The HLS URL is returned in the response.
-    #   The (<code>:rtmp</code>)  property is set  to an [Array] of Rtmp [Hash] properties.
-    #   For each RTMP , specify (<code>:serverUrl</code>) for the RTMP server URL,
+    #
+    #   For multiple RTMP streams, the (<code>:rtmp</code>) property is set to an [Array] of Rtmp [Hash] objects.
+    #   For each RTMP hash, specify (<code>:serverUrl</code>) for the RTMP server URL,
     #   (<code>:streamName</code>) such as the YouTube Live stream name or the Facebook stream key),
-    #   and (optionally) (<code>:id</code>), a unique ID for the stream.
+    #   and (optionally) (<code>:id</code>), a unique ID for the stream. If you specify an ID, it will be
+    #   included in the (<code>broadcast_json</code>) response from the Client#start_broadcast method call,
+    #   and is also available in the (<code>broadcast_json</code>) response from the Broadcasts#find method.
+    #   Vonage streams the session to each RTMP URL you specify. Note that OpenTok live streaming
+    #   supports RTMP and RTMPS.
+    #   If you need to support only one RTMP URL, you can set a Rtmp [Hash] object (instead of an array of
+    #   objects) for the (<code>:rtmp</code>) property value in the (<code>:outputs</code>) [Hash].
+    #
+    #   For HLS, the (<code>:hls</code>) property in the (<code>:outputs</code>) [Hash] is set to a HLS [Hash]
+    #   object. This object includes the following optional properties:
+    #   - (<code>:dvr</code>) (Boolean).  Whether to enable
+    #     {https://tokbox.com/developer/guides/broadcast/live-streaming/#dvr DVR functionality}
+    #     (rewinding, pausing, and resuming)
+    #     in players that support it (true), or not (false, the default). With DVR enabled, the HLS URL will
+    #     include a ?DVR query string appended to the end.
+    #   - (<code>:low_latency</code>) (Boolean). Whether to enable
+    #     {https://tokbox.com/developer/guides/broadcast/live-streaming/#low-latency low-latency mode}
+    #     for the HLSstream.
+    #     Some HLS players do not support low-latency mode. This feature is incompatible with DVR mode HLS
+    #     broadcasts (both can't be set to true). This is a beta feature.
+    #   The HLS URL is included in the (<code>broadcast_json</code>) response from the Client#start_broadcast
+    #   method call, and is also available in the (<code>broadcast_json</code>) response from the
+    #  Broadcasts#find method.
     #
     # @option options [string] resolution
     #   The resolution of the broadcast: either "640x480" (SD, the default) or "1280x720" (HD).
     #
+    # @option options [String] :streamMode (Optional) Whether streams included in the broadcast are selected
+    #   automatically ("auto", the default) or manually ("manual"). When streams are selected automatically ("auto"),
+    #   all streams in the session can be included in the broadcast. When streams are selected manually ("manual"),
+    #   you specify streams to be included based on calls to the
+    #   {Broadcasts#add_stream} method. You can specify whether a
+    #   stream's audio, video, or both are included in the broadcast.
+    #   For both automatic and manual modes, the broadcast composer includes streams based
+    #   on {https://tokbox.com/developer/guides/archive-broadcast-layout/#stream-prioritization-rules stream prioritization rules}.
+    #   Important: this feature is currently available in the Standard environment only.
+    #
     # @return [Broadcast] The broadcast object, which includes properties defining the broadcast,
     #   including the broadcast ID.
     #
     # @raise [OpenTokBroadcastError] The broadcast could not be started. The request was invalid or broadcast already started
-    # @raise [OpenTokAuthenticationError] Authentication failed while starting an archive.
+    # @raise [OpenTokAuthenticationError] Authentication failed while starting an broadcast.
     #   Invalid API key.
     # @raise [OpenTokError] OpenTok server error.
     def create(session_id, options = {})
       raise ArgumentError, "session_id not provided" if session_id.to_s.empty?
       raise ArgumentError, "options cannot be empty" if options.empty?
+      raise ArgumentError, "outputs property is required in options" unless options.has_key?(:outputs)
+      raise ArgumentError, "outputs must be a Hash" unless options[:outputs].is_a? Hash
+      if options[:outputs].has_key?(:hls)
+        dvr = options[:outputs][:hls][:dvr]
+        low_latency = options[:outputs][:hls][:low_latency]
+        raise ArgumentError, "dvr and low_latency can't both be true for HLS" if hls_dvr_and_low_latency_options_both_true?(dvr, low_latency)
+      end
       broadcast_json = @client.start_broadcast(session_id, options)
       Broadcast.new self, broadcast_json
     end
@@ -78,6 +124,25 @@ module OpenTok
       Broadcast.new self, broadcast_json
     end
 
+    # Returns a BroadcastList, which is an array of broadcasts that are completed and in-progress,
+    # for your API key.
+    #
+    # @param [Hash] options  A hash with keys defining which range of broadcasts to retrieve.
+    # @option options [integer] :offset Optional. The index offset of the first broadcast. 0 is offset
+    #   of the most recently started broadcast. 1 is the offset of the broadcast that started prior to
+    #   the most recent broadcast. If you do not specify an offset, 0 is used.
+    # @option options [integer] :count Optional. The number of broadcasts to be returned. The maximum
+    #   number of broadcasts returned is 1000.
+    # @option options [String] :session_id Optional. The session ID that broadcasts belong to.
+    # https://tokbox.com/developer/rest/#list_broadcasts
+    #
+    # @return [BroadcastList] An BroadcastList object, which is an array of Broadcast objects.
+    def all(options = {})
+      raise ArgumentError, "Limit is invalid" unless options[:count].nil? || (0..1000).include?(options[:count])
+
+      broadcast_list_json = @client.list_broadcasts(options[:offset], options[:count], options[:sessionId])
+      BroadcastList.new self, broadcast_list_json
+    end
 
     # Stops an OpenTok broadcast
     #
@@ -104,7 +169,7 @@ module OpenTok
     # @param [String] broadcast_id
     #   The broadcast ID.
     #
-    # @option options [String] :type 
+    # @option options [String] :type
     #   The layout type. Set this to "bestFit", "pip", "verticalPresentation",
     #   "horizontalPresentation", "focus", or "custom".
     #
@@ -112,6 +177,11 @@ module OpenTok
     #   The stylesheet for a custom layout. Set this parameter
     #   if you set <code>type</code> to <code>"custom"</code>. Otherwise, leave it undefined.
     #
+    # @option options [String] :screenshare_type
+    #   The screenshare layout type. Set this to "bestFit", "pip", "verticalPresentation" or
+    #   "horizonalPresentation". If this is defined, then the <code>type</code> parameter
+    #   must be set to <code>"bestFit"</code>.
+    #
     # @raise [OpenTokBroadcastError]
     #   The broadcast layout could not be updated.
     #
@@ -137,13 +207,94 @@ module OpenTok
       raise ArgumentError, "broadcast_id not provided" if broadcast_id.to_s.empty?
       type = options[:type]
       raise ArgumentError, "custom type must have a stylesheet" if (type.eql? "custom") && (!options.key? :stylesheet)
-      valid_non_custom_type = ["bestFit","horizontalPresentation","pip", "verticalPresentation", ""].include? type
+      valid_non_custom_layouts = ["bestFit","horizontalPresentation","pip", "verticalPresentation", ""]
+      valid_non_custom_type = valid_non_custom_layouts.include? type
       raise ArgumentError, "type is not valid" if !valid_non_custom_type && !(type.eql? "custom")
       raise ArgumentError, "stylesheet not needed" if valid_non_custom_type and options.key? :stylesheet
+      raise ArgumentError, "screenshare_type is not valid" if options[:screenshare_type] && !valid_non_custom_layouts.include?(options[:screenshare_type])
+      raise ArgumentError, "type must be set to 'bestFit' if screenshare_type is defined" if options[:screenshare_type] && type != 'bestFit'
       response = @client.layout_broadcast(broadcast_id, options)
       (200..300).include? response.code
     end
 
+    # Adds a stream to currently running broadcast that was started with the
+    # streamMode set to "manual". For a description of the feature, see
+    # {https://tokbox.com/developer/rest/#selecting-broadcast-streams}.
+    #
+    # @param [String] broadcast_id
+    #   The broadcast ID.
+    #
+    # @param [String] stream_id
+    #   The ID for the stream to be added to the broadcast
+    #
+    # @option opts [true, false] :has_audio
+    #   (Boolean, optional) — Whether the broadcast should include the stream's
+    #   audio (true, the default) or not (false).
+    #
+    # @option opts [true, false] :has_video
+    #   (Boolean, optional) — Whether the broadcast should include the stream's
+    #   video (true, the default) or not (false).
+    #
+    # You can call the method repeatedly with add_stream set to the same stream ID, to
+    # toggle the stream's audio or video in the broadcast. If you set both has_audio and
+    # has_video to false, you will get error response.
+    #
+    # @raise [ArgumentError]
+    #   The broadcast_id parameter is empty.
+    #
+    # @raise [ArgumentError]
+    #   The stream_id parameter is empty.
+    #
+    # @raise [ArgumentError]
+    #   The has_audio and has_video properties of the options parameter are both set to "false"
+    #
+    def add_stream(broadcast_id, stream_id, options)
+      raise ArgumentError, "broadcast_id not provided" if broadcast_id.to_s.empty?
+      raise ArgumentError, "stream_id not provided" if stream_id.to_s.empty?
+      if options.has_key?(:has_audio) && options.has_key?(:has_video)
+        has_audio = options[:has_audio]
+        has_video = options[:has_video]
+        raise ArgumentError, "has_audio and has_video can't both be false" if audio_and_video_options_both_false?(has_audio, has_video)
+      end
+      options['add_stream'] = stream_id
+
+      @client.select_streams_for_broadcast(broadcast_id, options)
+    end
+
+    # Removes a stream from a currently running broadcast that was started with the
+    # streamMode set to "manual". For a description of the feature, see
+    # {https://tokbox.com/developer/rest/#selecting-broadcast-streams}.
+    #
+    # @param [String] broadcast_id
+    #   The broadcast ID.
+    #
+    # @param [String] stream_id
+    #   The ID for the stream to be removed from the broadcast
+    #
+    # @raise [ArgumentError]
+    #   The broadcast_id parameter id is empty.
+    #
+    # @raise [ArgumentError]
+    #   The stream_id parameter is empty.
+    #
+    def remove_stream(broadcast_id, stream_id)
+      raise ArgumentError, "broadcast_id not provided" if broadcast_id.to_s.empty?
+      raise ArgumentError, "stream_id not provided" if stream_id.to_s.empty?
+      options = {}
+      options['remove_stream'] = stream_id
+
+      @client.select_streams_for_broadcast(broadcast_id, options)
+    end
+
+    private
+
+    def audio_and_video_options_both_false?(has_audio, has_video)
+      has_audio == false && has_video == false
+    end
+
+    def hls_dvr_and_low_latency_options_both_true?(dvr, low_latency)
+      dvr == true && low_latency == true
+    end
 
   end
 end

data/lib/opentok/client.rb

@@ -188,6 +188,33 @@ module OpenTok
       raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
     end
 
+    def select_streams_for_archive(archive_id, opts)
+      opts.extend(HashExtensions)
+      body = opts.camelize_keys!
+      response = self.class.patch("/v2/project/#{@api_key}/archive/#{archive_id}/streams", {
+          :body => body.to_json,
+          :headers => generate_headers("Content-Type" => "application/json")
+      })
+      case response.code
+      when 204
+        response
+      when 400
+        raise OpenTokArchiveError, "The request was invalid."
+      when 403
+        raise OpenTokAuthenticationError, "Authentication failed. API Key: #{@api_key}"
+      when 404
+        raise OpenTokArchiveError, "No matching archive found with the specified ID: #{archive_id}"
+      when 405
+        raise OpenTokArchiveError, "The archive was started with streamMode set to 'auto', which does not support stream manipulation."
+      when 500
+        raise OpenTokError, "OpenTok server error."
+      else
+        raise OpenTokArchiveError, "The archive streams could not be updated."
+      end
+    rescue StandardError => e
+      raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
+    end
+
     def forceDisconnect(session_id, connection_id)
       response = self.class.delete("/v2/project/#{@api_key}/session/#{session_id}/connection/#{connection_id}", {
           :headers => generate_headers("Content-Type" => "application/json")
@@ -206,6 +233,45 @@ module OpenTok
       raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
     end
 
+    def force_mute_stream(session_id, stream_id)
+      response = self.class.post("/v2/project/#{@api_key}/session/#{session_id}/stream/#{stream_id}/mute", {
+          :headers => generate_headers("Content-Type" => "application/json")
+      })
+      case response.code
+      when 200
+        response
+      when 400
+        raise ArgumentError, "Force mute failed. Stream ID #{stream_id} or Session ID #{session_id} is invalid"
+      when 403
+        raise OpenTokAuthenticationError, "Authentication failed. API Key: #{@api_key}"
+      when 404
+        raise OpenTokConnectionError, "Either Stream ID #{stream_id} or Session ID #{session_id} is invalid"
+      end
+    rescue StandardError => e
+      raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
+    end
+
+    def force_mute_session(session_id, opts)
+      opts.extend(HashExtensions)
+      body = opts.camelize_keys!
+      response = self.class.post("/v2/project/#{@api_key}/session/#{session_id}/mute", {
+          :body => body.to_json,
+          :headers => generate_headers("Content-Type" => "application/json")
+      })
+      case response.code
+      when 200
+        response
+      when 400
+        raise ArgumentError, "Force mute failed. The request could not be processed due to a bad request"
+      when 403
+        raise OpenTokAuthenticationError, "Authentication failed. API Key: #{@api_key}"
+      when 404
+        raise OpenTokConnectionError, "Session ID #{session_id} is invalid"
+      end
+    rescue StandardError => e
+      raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
+    end
+
     def signal(session_id, connection_id, opts)
       opts.extend(HashExtensions)
       connectionPath = connection_id.to_s.empty? ? "" : "/connection/#{connection_id}"
@@ -257,6 +323,52 @@ module OpenTok
       raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
     end
 
+    def play_dtmf_to_connection(session_id, connection_id, dtmf_digits)
+      body = { "digits" => dtmf_digits }
+
+      response = self.class.post("/v2/project/#{@api_key}/session/#{session_id}/connection/#{connection_id}/play-dtmf", {
+        :body => body.to_json,
+        :headers => generate_headers("Content-Type" => "application/json")
+      })
+      case response.code
+      when 200
+        response
+      when 400
+        raise ArgumentError, "One of the properties — dtmf_digits #{dtmf_digits} or session_id #{session_id} — is invalid."
+      when 403
+        raise OpenTokAuthenticationError, "Authentication failed. This can occur if you use an invalid OpenTok API key or an invalid JSON web token. API Key: #{@api_key}"
+      when 404
+        raise OpenTokError, "The specified session #{session_id} does not exist or the client specified by the #{connection_id} property is not connected to the session."
+      else
+        raise OpenTokError, "An error occurred when attempting to play DTMF digits to the session"
+      end
+    rescue StandardError => e
+      raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
+    end
+
+    def play_dtmf_to_session(session_id, dtmf_digits)
+      body = { "digits" => dtmf_digits }
+
+      response = self.class.post("/v2/project/#{@api_key}/session/#{session_id}/play-dtmf", {
+        :body => body.to_json,
+        :headers => generate_headers("Content-Type" => "application/json")
+      })
+      case response.code
+      when 200
+        response
+      when 400
+        raise ArgumentError, "One of the properties — dtmf_digits #{dtmf_digits} or session_id #{session_id} — is invalid."
+      when 403
+        raise OpenTokAuthenticationError, "Authentication failed. This can occur if you use an invalid OpenTok API key or an invalid JSON web token. API Key: #{@api_key}"
+      when 404
+        raise OpenTokError, "The specified session does not exist. Session ID: #{session_id}"
+      else
+        raise OpenTokError, "An error occurred when attempting to play DTMF digits to the session"
+      end
+    rescue StandardError => e
+      raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
+    end
+
     def info_stream(session_id, stream_id)
       streamId = stream_id.to_s.empty? ? '' : "/#{stream_id}"
       url = "/v2/project/#{@api_key}/session/#{session_id}/stream#{streamId}"
@@ -371,6 +483,28 @@ module OpenTok
       raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
     end
 
+    def list_broadcasts(offset, count, session_id)
+      query = Hash.new
+      query[:offset] = offset unless offset.nil?
+      query[:count] = count unless count.nil?
+      query[:sessionId] = session_id unless session_id.nil?
+      response = self.class.get("/v2/project/#{@api_key}/broadcast", {
+        :query => query.empty? ? nil : query,
+        :headers => generate_headers,
+      })
+      case response.code
+      when 200
+        response
+      when 403
+        raise OpenTokAuthenticationError,
+          "Authentication failed while retrieving broadcasts. API Key: #{@api_key}"
+      else
+        raise OpenTokBroadcastError, "The broadcasts could not be retrieved."
+      end
+    rescue StandardError => e
+      raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
+    end
+
     def layout_broadcast(broadcast_id, opts)
       opts.extend(HashExtensions)
       response = self.class.put("/v2/project/#{@api_key}/broadcast/#{broadcast_id}/layout", {
@@ -393,5 +527,32 @@ module OpenTok
       raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
     end
 
+    def select_streams_for_broadcast(broadcast_id, opts)
+      opts.extend(HashExtensions)
+      body = opts.camelize_keys!
+      response = self.class.patch("/v2/project/#{@api_key}/broadcast/#{broadcast_id}/streams", {
+          :body => body.to_json,
+          :headers => generate_headers("Content-Type" => "application/json")
+      })
+      case response.code
+      when 204
+        response
+      when 400
+        raise OpenTokBroadcastError, "The request was invalid."
+      when 403
+        raise OpenTokAuthenticationError, "Authentication failed. API Key: #{@api_key}"
+      when 404
+        raise OpenTokBroadcastError, "No matching broadcast found with the specified ID: #{broadcast_id}"
+      when 405
+        raise OpenTokBroadcastError, "The broadcast was started with streamMode set to 'auto', which does not support stream manipulation."
+      when 500
+        raise OpenTokError, "OpenTok server error."
+      else
+        raise OpenTokBroadcastError, "The broadcast streams could not be updated."
+      end
+    rescue StandardError => e
+      raise OpenTokError, "Failed to connect to OpenTok. Response code: #{e.message}"
+    end
+
   end
 end

data/lib/opentok/connections.rb

@@ -25,4 +25,4 @@ module OpenTok
     end
 
   end
-end
+end

data/lib/opentok/constants.rb

@@ -1,4 +1,5 @@
 module OpenTok
+  require "set"
   API_URL = "https://api.opentok.com"
   TOKEN_SENTINEL = "T1=="
   ROLES = { subscriber: "subscriber", publisher: "publisher", moderator: "moderator" }

data/lib/opentok/opentok.rb

@@ -1,3 +1,6 @@
+require "resolv"
+require "set"
+
 require "opentok/constants"
 require "opentok/session"
 require "opentok/client"
@@ -9,9 +12,6 @@ require "opentok/streams"
 require "opentok/signals"
 require "opentok/broadcasts"
 
-require "resolv"
-require "set"
-
 module OpenTok
   # Contains methods for creating OpenTok sessions and generating tokens. It also includes
   # methods for returning object that let you work with archives, work with live streaming
@@ -42,9 +42,9 @@ module OpenTok
   #       streams, and signal. (This is the default value if you do not specify a role.)
   #
   #     * <code>:moderator</code> -- In addition to the privileges granted to a
-  #       publisher, in clients using the OpenTok.js library, a moderator can call the
-  #       <code>forceUnpublish()</code> and <code>forceDisconnect()</code> method of the
-  #       Session object.
+  #       publisher, a moderator can perform moderation functions, such as forcing clients
+  #       to disconnect, to stop publishing streams, or to mute audio in published streams. See the
+  #       {https://tokbox.com/developer/guides/moderation/ Moderation developer guide}.
   #   @option options [integer] :expire_time The expiration time, in seconds since the UNIX epoch.
   #     Pass in 0 to use the default expiration time of 24 hours after the token creation time.
   #     The maximum expiration time is 30 days after the creation time.
@@ -77,8 +77,8 @@ module OpenTok
     # @param [String] api_key The OpenTok API key for your
     #   {https://tokbox.com/account OpenTok project}.
     # @param [String] api_secret Your OpenTok API key.
-    # @option opts [Symbol] :api_url Do not set this parameter. It is for internal use by TokBox.
-    # @option opts [Symbol] :ua_addendum Do not set this parameter. It is for internal use by TokBox.
+    # @option opts [Symbol] :api_url Do not set this parameter. It is for internal use by Vonage.
+    # @option opts [Symbol] :ua_addendum Do not set this parameter. It is for internal use by Vonage.
     # @option opts [Symbol] :timeout_length Custom timeout in seconds. If not provided, defaults to 2 seconds.
     def initialize(api_key, api_secret, opts={})
       @api_key = api_key.to_s()
@@ -207,7 +207,7 @@ module OpenTok
       @signals ||= Signals.new client
     end
 
-    # A Connections object, which lets disconnect clients from an OpenTok session.
+    # A Connections object, which lets you disconnect clients from an OpenTok session.
     def connections
       @connections ||= Connections.new client
     end

data/lib/opentok/sip.rb

@@ -12,7 +12,9 @@ module OpenTok
     #        "password" => sip_password },
     #      "headers" => { "X-KEY1" => "value1",
     #        "X-KEY1" => "value2" },
-    #      "secure" => "true"
+    #      "secure" => "true",
+    #      "video" => "true",
+    #      "observe_force_mute" => "true"
     #    }
     #    response = opentok.sip.dial(session_id, token, "sip:+15128675309@acme.pstn.example.com;transport=tls", opts)
     # @param [String] session_id The session ID corresponding to the session to which
@@ -33,14 +35,50 @@ module OpenTok
     # @option opts [Hash] :auth This object contains the username and password
     #   to be used in the the SIP INVITE​ request for HTTP digest authentication,
     #   if it is required by your SIP platform.
-    # @option opts  [true, false] :secure Wether the media must be transmitted
+    # @option opts  [true, false] :secure Whether the media must be transmitted
     #   encrypted (​true​) or not (​false​, the default).
+    # @option opts  [true, false] :video Whether the SIP call will include
+    # video (​true​) or not (​false​, the default). With video included, the SIP
+    # client's video is included in the OpenTok stream that is sent to the
+    # OpenTok session. The SIP client will receive a single composed video of
+    # the published streams in the OpenTok session.
+    # @option opts  [true, false] :observe_force_mute Whether the SIP end point
+    # observes {https://tokbox.com/developer/guides/moderation/#force_mute force mute moderation}
+    # (true) or not (false, the default).
     def dial(session_id, token, sip_uri, opts)
       response = @client.dial(session_id, token, sip_uri, opts)
     end
 
+    # Sends DTMF digits to a specific client connected to an OpnTok session.
+    #
+    # @param [String] session_id The session ID.
+    # @param [String] connection_id The connection ID of the specific connection that
+    # the DTMF signal is being sent to.
+    # @param [String] dtmf_digits The DTMF digits to send. This can include 0-9, "*", "#", and "p".
+    # A p indicates a pause of 500ms (if you need to add a delay in sending the digits).
+    def play_dtmf_to_connection(session_id, connection_id, dtmf_digits)
+      raise ArgumentError, "invalid DTMF digits" unless dtmf_digits_valid?(dtmf_digits)
+      response = @client.play_dtmf_to_connection(session_id, connection_id, dtmf_digits)
+    end
+
+    # Sends DTMF digits to all clients connected to an OpnTok session.
+    #
+    # @param [String] session_id The session ID.
+    # @param [String] dtmf_digits The DTMF digits to send. This can include 0-9, "*", "#", and "p".
+    # A p indicates a pause of 500ms (if you need to add a delay in sending the digits).
+    def play_dtmf_to_session(session_id, dtmf_digits)
+      raise ArgumentError, "invalid DTMF digits" unless dtmf_digits_valid?(dtmf_digits)
+      response = @client.play_dtmf_to_session(session_id, dtmf_digits)
+    end
+
     def initialize(client)
       @client = client
     end
+
+    private
+
+    def dtmf_digits_valid?(dtmf_digits)
+      dtmf_digits.match?(/^[0-9*#p]+$/)
+    end
   end
 end

data/lib/opentok/streams.rb

@@ -75,5 +75,52 @@ module OpenTok
       (200..300).include? response.code
     end
 
+    # Force a specific stream connected to an OpenTok session to mute itself.
+    #
+    # @param [String] session_id The session ID of the OpenTok session.
+    # @param [String] stream_id The stream ID of the stream in the session.
+    #
+    def force_mute(session_id, stream_id)
+      response = @client.force_mute_stream(session_id, stream_id)
+    end
+
+    # Force all streams connected to an OpenTok session (except for an optional list of streams),
+    # to mute published audio.
+    # 
+    # In addition to existing streams, any streams that are published after the call to
+    # this method are published with audio muted. You can remove the mute state of a session
+    # by calling the disable_force_mute() method.
+    #
+    # @param [String] session_id The session ID.
+    # @param [Hash] opts An optional hash defining options for the muting action. For example:
+    #   {
+    #     "excluded_streams" => [
+    #       "excludedStreamId1",
+    #       "excludedStreamId2"
+    #     ]
+    #   }
+    # @option opts [Array] :excluded_streams The stream IDs for streams that should not be muted.
+    # This is an optional property. If you omit this property, all streams in the session will be muted.
+    #
+    def force_mute_all(session_id, opts = {})
+      opts['active'] = 'true'
+      response = @client.force_mute_session(session_id, opts)
+    end
+
+    # Disables the active mute state of the session. After you call this method, new streams
+    # published to the session will no longer have audio muted.
+    #
+    # After you call the force_mute_all() method, any streams published after
+    # the call are published with audio muted. Call the disable_force_mute() method
+    # to remove the mute state of a session, so that new published streams are not
+    # automatically muted.
+    #
+    # @param [String] session_id The session ID.
+    #
+    def disable_force_mute(session_id)
+      opts = {'active' => 'false'}
+      response = @client.force_mute_session(session_id, opts)
+    end
+
   end
-end
+end

data/lib/opentok/token_generator.rb

@@ -4,6 +4,7 @@ require "opentok/session"
 require "base64"
 require "addressable/uri"
 require "openssl"
+require "active_support"
 require "active_support/time"
 
 module OpenTok

data/lib/opentok/version.rb

@@ -1,4 +1,4 @@
 module OpenTok
   # @private
-  VERSION = '4.1.2'
+  VERSION = '4.4.0'
 end

data/opentok.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
 
   bundler_version = RUBY_VERSION < '2.1' ? '~> 1.5' : '>= 1.5'
   spec.add_development_dependency "bundler", bundler_version
-  spec.add_development_dependency "rake", "~> 12.0.0"
+  spec.add_development_dependency "rake", "~> 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.9.0"
   spec.add_development_dependency "webmock", ">= 2.3.2"
   spec.add_development_dependency "vcr", ">= 2.8.0"