93bbff8bd0bb41199cb6381e110acc5717938d4f

Committed 28 May 2025 03:47AM UTC coverage: 92.434% (-0.2%) from 92.638%

Build # 93bbff8bd0bb41199cb6381e110acc5717938d4f

Build Type

push

github

Committed by

web-flow

Commit Message

fix(deps): update rust crate once_cell to v1.21.3 (#346)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Coverage Stats

452 of 489 relevant lines covered (92.43%)

35.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.26

/lib/data_consumer.ex

defmodule Mediasoup.DataConsumer do
  @moduledoc """
  https://mediasoup.org/documentation/v3/mediasoup/api/#DataConsumer
  """
  alias Mediasoup.{DataConsumer, NifWrap, Nif}
  require NifWrap
  use GenServer, restart: :temporary

  @enforce_keys [:id, :data_producer_id, :type, :sctp_stream_parameters]
  defstruct [:id, :data_producer_id, :type, :sctp_stream_parameters, :label, :protocol, :pid]

  @type t :: %DataConsumer{
          id: String.t(),
          data_producer_id: String.t(),
          type: type,
          sctp_stream_parameters: sctpStreamParameters,
          label: String.t(),
          protocol: String.t(),
          pid: pid
        }

  @typedoc """
  https://mediasoup.org/documentation/v3/mediasoup/sctp-parameters/#SctpStreamParameters
  """
  @type sctpStreamParameters :: map

  @typedoc """
  https://mediasoup.org/documentation/v3/mediasoup/api/#DataConsumerType
   "sctp" or "direct"
  """
  @type type :: String.t()

  @spec id(t) :: String.t()
  def id(%{id: id}) do
    id
  end

  @spec data_producer_id(t) :: String.t()
  def data_producer_id(%{data_producer_id: data_producer_id}) do
    data_producer_id
  end

  @spec type(t) :: type
  def type(%{type: type}) do
    type
  end

  @spec sctp_stream_parameters(t) :: sctpStreamParameters
  def sctp_stream_parameters(%{sctp_stream_parameters: sctp_stream_parameters}) do
    sctp_stream_parameters
  end

  @spec label(t) :: String.t()
  def label(%{label: label}) do
    label
  end

  @spec protocol(t) :: String.t()
  def protocol(%{protocol: protocol}) do
    protocol
  end

  @spec close(t) :: :ok
  def close(%DataConsumer{pid: pid}) do
    GenServer.stop(pid)
  end

  @spec closed?(t) :: boolean
  def closed?(%DataConsumer{pid: pid}) do
    !Process.alive?(pid) || NifWrap.call(pid, {:closed?, []})
  end

  @type event_type :: :on_close
  @spec event(t, pid, event_types :: [event_type]) :: {:ok} | {:error, :terminated}
  def event(%DataConsumer{pid: pid}, listener, event_types \\ [:on_close]) do
    NifWrap.call(pid, {:event, [listener, event_types]})
  end

  @spec struct_from_pid(pid()) :: DataConsumer.t()
  def struct_from_pid(pid) when is_pid(pid) do
    GenServer.call(pid, {:struct_from_pid, []})
  end

  def struct_from_pid_and_ref(pid, reference) do
    %DataConsumer{
      pid: pid,
      id: Nif.data_consumer_id(reference),
      data_producer_id: Nif.data_consumer_producer_id(reference),
      type: Nif.data_consumer_type(reference),
      sctp_stream_parameters: Nif.data_consumer_sctp_stream_parameters(reference),
      label: Nif.data_consumer_label(reference),
      protocol: Nif.data_consumer_protocol(reference)
    }
  end

  # GenServer callbacks

  def start_link(opt) do
    reference = Keyword.fetch!(opt, :reference)
    GenServer.start_link(__MODULE__, %{reference: reference}, opt)
  end

  @impl true
  def init(state) do
    Process.flag(:trap_exit, true)
    {:ok, state}
  end

  @impl true
  def handle_call({:event, [listener, event_types]}, _from, %{reference: reference} = state) do
    result =
      case NifWrap.EventProxy.wrap_if_remote_node(listener) do
        pid when is_pid(pid) -> Nif.data_consumer_event(reference, pid, event_types)
      end

    {:reply, result, state}
  end

  @impl true
  def handle_call({:struct_from_pid, _arg}, _from, %{reference: reference} = state) do
    {:reply, struct_from_pid_and_ref(self(), reference), state}
  end

  @impl true
  def handle_info({:on_close}, state) do
    {:stop, :normal, state}
  end

  NifWrap.def_handle_call_nif(%{
    closed?: &Nif.data_consumer_closed/1
  })

  @impl true
  def terminate(_reason, %{reference: reference} = _state) do
    Nif.data_consumer_close(reference)
    :ok
  end

  defmodule Options do
    @moduledoc """
    https://mediasoup.org/documentation/v3/mediasoup/api/#DataConsumerOptions
    """

    @enforce_keys [:data_producer_id]
    defstruct [:data_producer_id, ordered: nil, max_packet_life_time: nil, max_retransmits: nil]

    @type t :: %Options{
            data_producer_id: String.t(),
            ordered: boolean | nil,
            max_packet_life_time: integer | nil,
            max_retransmits: integer | nil
          }

    def from_map(%{} = map) do
      map = for {key, val} <- map, into: %{}, do: {to_string(key), val}

      %Options{
        data_producer_id: map["dataProducerId"],
        ordered: map["ordered"],
        max_packet_life_time: map["maxPacketLifeTime"],
        max_retransmits: map["maxRetransmits"]
      }
    end
  end
end

1	defmodule Mediasoup.DataConsumer do
2	@moduledoc """
3	https://mediasoup.org/documentation/v3/mediasoup/api/#DataConsumer
4	"""
5	alias Mediasoup.{DataConsumer, NifWrap, Nif}
6	require NifWrap
7	use GenServer, restart: :temporary
8
9	@enforce_keys [:id, :data_producer_id, :type, :sctp_stream_parameters]
10	defstruct [:id, :data_producer_id, :type, :sctp_stream_parameters, :label, :protocol, :pid]
11
12	@type t :: %DataConsumer{
13	id: String.t(),
14	data_producer_id: String.t(),
15	type: type,
16	sctp_stream_parameters: sctpStreamParameters,
17	label: String.t(),
18	protocol: String.t(),
19	pid: pid
20	}
21
22	@typedoc """
23	https://mediasoup.org/documentation/v3/mediasoup/sctp-parameters/#SctpStreamParameters
24	"""
25	@type sctpStreamParameters :: map
26
27	@typedoc """
28	https://mediasoup.org/documentation/v3/mediasoup/api/#DataConsumerType
29	"sctp" or "direct"
30	"""
31	@type type :: String.t()
32
33	@spec id(t) :: String.t()
34	def id(%{id: id}) do
35	id	1✔
36	end
37
38	@spec data_producer_id(t) :: String.t()
39	def data_producer_id(%{data_producer_id: data_producer_id}) do
40	data_producer_id	1✔
41	end
42
43	@spec type(t) :: type
44	def type(%{type: type}) do
45	type	1✔
46	end
47
48	@spec sctp_stream_parameters(t) :: sctpStreamParameters
49	def sctp_stream_parameters(%{sctp_stream_parameters: sctp_stream_parameters}) do
50	sctp_stream_parameters	4✔
51	end
52
53	@spec label(t) :: String.t()
54	def label(%{label: label}) do
55	label	1✔
56	end
57
58	@spec protocol(t) :: String.t()
59	def protocol(%{protocol: protocol}) do
60	protocol	1✔
61	end
62
63	@spec close(t) :: :ok
64	def close(%DataConsumer{pid: pid}) do
65	GenServer.stop(pid)	6✔
66	end
67
68	@spec closed?(t) :: boolean
69	def closed?(%DataConsumer{pid: pid}) do
70	!Process.alive?(pid) \|\| NifWrap.call(pid, {:closed?, []})	3✔
71	end
72
73	@type event_type :: :on_close
74	@spec event(t, pid, event_types :: [event_type]) :: {:ok} \| {:error, :terminated}
75	def event(%DataConsumer{pid: pid}, listener, event_types \\ [:on_close]) do
76	NifWrap.call(pid, {:event, [listener, event_types]})	3✔
77	end
78
79	@spec struct_from_pid(pid()) :: DataConsumer.t()
80	def struct_from_pid(pid) when is_pid(pid) do
81	GenServer.call(pid, {:struct_from_pid, []})	×
82	end
83
84	def struct_from_pid_and_ref(pid, reference) do
85	%DataConsumer{	11✔
86	pid: pid,
87	id: Nif.data_consumer_id(reference),
88	data_producer_id: Nif.data_consumer_producer_id(reference),
89	type: Nif.data_consumer_type(reference),
90	sctp_stream_parameters: Nif.data_consumer_sctp_stream_parameters(reference),
91	label: Nif.data_consumer_label(reference),
92	protocol: Nif.data_consumer_protocol(reference)
93	}
94	end
95
96	# GenServer callbacks
97
98	def start_link(opt) do
99	reference = Keyword.fetch!(opt, :reference)	11✔
100	GenServer.start_link(__MODULE__, %{reference: reference}, opt)	11✔
101	end
102
103	@impl true
104	def init(state) do
105	Process.flag(:trap_exit, true)	11✔
106	{:ok, state}
107	end
108
109	@impl true
110	def handle_call({:event, [listener, event_types]}, _from, %{reference: reference} = state) do
111	result =	3✔
112	case NifWrap.EventProxy.wrap_if_remote_node(listener) do
113	pid when is_pid(pid) -> Nif.data_consumer_event(reference, pid, event_types)	3✔
114	end
115
116	{:reply, result, state}	3✔
117	end
118
119	@impl true
120	def handle_call({:struct_from_pid, _arg}, _from, %{reference: reference} = state) do
121	{:reply, struct_from_pid_and_ref(self(), reference), state}	×
122	end
123
124	@impl true
125	def handle_info({:on_close}, state) do
126	{:stop, :normal, state}	×
127	end
128
129	NifWrap.def_handle_call_nif(%{	2✔
130	closed?: &Nif.data_consumer_closed/1
131	})
132
133	@impl true
134	def terminate(_reason, %{reference: reference} = _state) do
135	Nif.data_consumer_close(reference)	11✔
136	:ok
137	end
138
139	defmodule Options do
140	@moduledoc """
141	https://mediasoup.org/documentation/v3/mediasoup/api/#DataConsumerOptions
142	"""
143
144	@enforce_keys [:data_producer_id]
145	defstruct [:data_producer_id, ordered: nil, max_packet_life_time: nil, max_retransmits: nil]
146
147	@type t :: %Options{
148	data_producer_id: String.t(),
149	ordered: boolean \| nil,
150	max_packet_life_time: integer \| nil,
151	max_retransmits: integer \| nil
152	}
153
154	def from_map(%{} = map) do
155	map = for {key, val} <- map, into: %{}, do: {to_string(key), val}	×
156
157	%Options{	×
158	data_producer_id: map["dataProducerId"],
159	ordered: map["ordered"],
160	max_packet_life_time: map["maxPacketLifeTime"],
161	max_retransmits: map["maxRetransmits"]
162	}
163	end
164	end
165	end

oviceinc / mediasoup-elixir / 93bbff8bd0bb41199cb6381e110acc5717938d4f

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous