Skip to content
Snippets Groups Projects
serverfunctions.liq 7.37 KiB
Newer Older
  • Learn to ignore specific revisions
  • #
    # Aura Engine (https://gitlab.servus.at/aura/engine)
    #
    # Copyright (C) 2017-2020 - The Aura Engine Team.
    #
    # This program is free software: you can redistribute it and/or modify
    # it under the terms of the GNU Affero General Public License as published by
    # the Free Software Foundation, either version 3 of the License, or
    # (at your option) any later version.
    #
    # This program is distributed in the hope that it will be useful,
    # but WITHOUT ANY WARRANTY; without even the implied warranty of
    # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    # GNU Affero General Public License for more details.
    #
    # You should have received a copy of the GNU Affero General Public License
    # along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
    
    
    def icy_update(v) =
    
      # Parse the argument
      l = string.split(separator=",",v)
      def split(l,v) =
        v = string.split(separator="=",v)
        if list.length(v) >= 2 then
          list.append(l,[(list.nth(v,0,default=""),list.nth(v,1,default=""))])
        else
          l
        end
      end
      meta = list.fold(split,[],l)
    
    
      # Update metadata
    
      if s0_enable == true then
        icy.update_metadata(
            mount=s0_mount,
            user=s0_user,
            password=s0_pass,
            host=s0_host,
            port=s0_port,
            meta
            )
      end
    
      if s1_enable == true then
        icy.update_metadata(
            mount=s1_mount,
            user=s1_user,
            password=s1_pass,
            host=s1_host,
            port=s1_port,
            meta
            )
      end
    
      if s2_enable == true then
        icy.update_metadata(
            mount=s2_mount,
            user=s2_user,
            password=s2_pass,
            host=s2_host,
            port=s2_port,
            meta
            )
      end
    
      if s3_enable == true then
        icy.update_metadata(
            mount=s3_mount,
            user=s3_user,
            password=s3_pass,
            host=s3_host,
            port=s3_port,
            meta
            )
      end
    
      if s4_enable == true then
        icy.update_metadata(
            mount=s4_mount,
            user=s4_user,
            password=s4_pass,
            host=s4_host,
            port=s4_port,
            meta
            )
      end
    
      "Done!"
    end
    
    server.register("update", namespace="metadata",
                     description="Update metadata",
                     usage="update title=foo,album=bar, ...",
                     icy_update)
    
    
    # shutdown server function
    #server.register(namespace='server',
    #    description="shutdown server",
    #    usage="stop",
    #    "stop",
    #    fun(x,y) -> shutdown )
    
    
    
    #
    # to reduce complexity of lqs => query 'mixer.inputs' over socket and parse it in python
    #server.register(namespace="auraengine",
    #    "enabled_lineins",
    #    fun (s) -> begin
    #        log("auraengine.enabled_lineins")
    #        "0:#{!linein_0_enabled}, 1:#{!linein_1_enabled}, 2:#{!linein_2_enabled}, 3:#{!linein_3_enabled}, 4:#{!linein_4_enabled}"
    #    end
    #)
    
    #server.register(namespace="auraengine",
    #    "enabled_lineouts",
    #    fun(s) -> begin
    #        log("auraengine.enabled_lineouts")
    #        "0:#{!lineout_0_enabled}, 1:#{!lineout_1_enabled}, 2:#{!lineout_2_enabled}, 3:#{!lineout_3_enabled}, 4:#{!lineout_4_enabled}"
    #    end
    #)
    
    
    # are outgoing streams connected?
    server.register(namespace="auraengine",
        description="returns the version of Engine Core",
        usage="version",
        "version",
        fun (s) -> begin
            engine_version
        end
    )
    
    
    # are outgoing streams connected?
    server.register(namespace="auraengine",
        description="returns if outgoing streams are connected",
        usage="out_streams_connected",
        "out_streams_connected",
        fun (s) -> begin
            log("streams.connection_status")
            "0:#{!s0_connected}, 1:#{!s1_connected}, 2:#{!s2_connected}, 3:#{!s3_connected}, 4:#{!s4_connected}"
        end
    )
    
    # return a state of the inputs/outputs of the soundserver as JSON
    server.register(namespace = "auraengine",
    
        description="returns enabled line-in, line-out and connected outgoing streams",
    
        usage="state",
        "state",
        fun(s) -> begin
            log("auraengine.state")
    
            ret = '{'
            ret = ret^'"streams": {'
            ret = ret^'"stream_0": {"enabled": #{s0_enable}, "connected": #{!s0_connected}},'
            ret = ret^'"stream_1": {"enabled": #{s1_enable}, "connected": #{!s1_connected}},'
            ret = ret^'"stream_2": {"enabled": #{s2_enable}, "connected": #{!s2_connected}},'
            ret = ret^'"stream_3": {"enabled": #{s3_enable}, "connected": #{!s3_connected}},'
            ret = ret^'"stream_4": {"enabled": #{s4_enable}, "connected": #{!s4_connected}}'
            ret = ret^'},'
            ret = ret^'"linein": {'
            ret = ret^'"linein_0": {"enabled": #{a0_in != ""}},'
            ret = ret^'"linein_1": {"enabled": #{a1_in != ""}},'
            ret = ret^'"linein_2": {"enabled": #{a2_in != ""}},'
            ret = ret^'"linein_3": {"enabled": #{a3_in != ""}},'
            ret = ret^'"linein_4": {"enabled": #{a4_in != ""}}'
            ret = ret^'},'
            ret = ret^'"lineout": {'
            ret = ret^'"lineout_0": {"enabled": #{a0_out != ""}},'
            ret = ret^'"lineout_1": {"enabled": #{a1_out != ""}},'
            ret = ret^'"lineout_2": {"enabled": #{a2_out != ""}},'
            ret = ret^'"lineout_3": {"enabled": #{a3_out != ""}},'
            ret = ret^'"lineout_4": {"enabled": #{a4_out != ""}}'
            ret = ret^'}'
            ret = ret^'}'
            ret
    
            # outgoing streams enabled?
    
            #ret = "stream_0_enabled:#{!s0_enable}, stream_1_enabled:#{!s1_enable}, stream_2_enabled:#{!s2_enable}, stream_3_enabled:#{!s3_enable}, stream_4_enabled:#{!s4_enable}, "
    
            #ret = ret^"linein_0_enabled:#{a0_in != ''}, linein_1_enabled:#{a1_in != ''}, linein_2_enabled:#{a2_in != ''}, linein_3_enabled:#{a3_in != ''}, linein_4_enabled:#{a4_in != ''}, "
            #ret = ret^"lineout_0_enabled:#{a0_out != ''}, lineout_1_enabled:#{a1_out != ''}, lineout_2_enabled:#{a2_out != ''}, lineout_3_enabled:#{a3_out != ''}, lineout_4_enabled:#{a4_out != ''}, "
            #ret = ret^"fallback_max_blank:#{fallback_max_blank}, fallback_min_noise:#{fallback_min_noise}, fallback_threshold:#{fallback_threshold}"
    
        end
    )
    
    
    def fadeTo(source_number) =
        if source_number == "" then
            print(source_number)
            "Usage: mixer.fadeto <source nb> #{source_number}"
        else
            r = server.execute("mixer.select #{source_number} true")
            print(r)
            "Donee!"
        end
    end
    
    # enable fadeTo for the mixer
    server.register(namespace = "mixer",
        description = "is fading from one mixer input to another",
        usage = "fadeto <source number>",
        "fadeto",
        fadeTo
    )
    
    ignore(fade_in_time)
    ignore(fade_out_time)
    
    
    # Activate a source by selecting it and setting the volume to 100 (or vice versa)
    
    def activate(p) =
    
        params=string.split(separator=" ", p)
    
        if list.length(params) < 2 then
            print(p)
            "Usage: mixer.activate <source nb> <true|false>"
        else
            source_number = list.nth(default="0", params, 0)
            source_enable = list.nth(default="false", params, 1)
    
            if source_enable == "true" then
                r = server.execute("mixer.select #{source_number} true")
                print(r)
                r = server.execute("mixer.volume #{source_number} 100")
                print(r)
            else
                r = server.execute("mixer.volume #{source_number} 0")
                print(r)
                r = server.execute("mixer.select #{source_number} false")
                print(r)
            end
            "Done!"
        end
    end
    
    server.register(namespace = "mixer",
        description = "is selecting a source and setting the volume to 100",
        usage = "activate <source nb> <true|false>",
        "activate",
        activate
    )