In the warm transfer example, add hold music

Author: kompfner

examples/dynamic/hold_music/README.md

@@ -0,0 +1,7 @@
+# Hold Music Player
+
+This project is a hold music player, based on the `wav_audio_send` example from the [daily-python repository](https://github.com/daily-co/daily-python/blob/main/demos/audio/wav_audio_send.py).
+
+The hold music WAV file used in this example was sourced from [No Copyright Music](https://www.no-copyright-music.com/).
+
+To see this hold music player in use, check out the [warm transfer example](../warm_transfer.py).

examples/dynamic/hold_music/hold_music.py

@@ -0,0 +1,108 @@
+#
+# This demo will join a Daily meeting and send the audio from a WAV file into
+# the meeting.
+#
+# Usage: python3 wav_audio_send.py -m MEETING_URL -i FILE.wav
+#
+
+import argparse
+import threading
+import wave
+
+from daily import *
+
+SAMPLE_RATE = 16000
+NUM_CHANNELS = 1
+
+
+class SendWavApp:
+    def __init__(self, input_file_name, sample_rate, num_channels):
+        self.__mic_device = Daily.create_microphone_device(
+            "my-mic", sample_rate=sample_rate, channels=num_channels
+        )
+
+        self.__client = CallClient()
+
+        self.__client.update_subscription_profiles(
+            {"base": {"camera": "unsubscribed", "microphone": "unsubscribed"}}
+        )
+
+        self.__app_quit = False
+        self.__app_error = None
+
+        self.__start_event = threading.Event()
+        self.__thread = threading.Thread(target=self.send_wav_file, args=[input_file_name])
+        self.__thread.start()
+
+    def on_joined(self, data, error):
+        if error:
+            print(f"Unable to join meeting: {error}")
+            self.__app_error = error
+        self.__start_event.set()
+
+    def run(self, meeting_url, meeting_token):
+        self.__client.join(
+            meeting_url,
+            meeting_token,
+            client_settings={
+                "inputs": {
+                    "camera": False,
+                    "microphone": {"isEnabled": True, "settings": {"deviceId": "my-mic"}},
+                }
+            },
+            completion=self.on_joined,
+        )
+        self.__thread.join()
+
+    def leave(self):
+        self.__app_quit = True
+        self.__thread.join()
+        self.__client.leave()
+        self.__client.release()
+
+    def send_wav_file(self, file_name):
+        self.__start_event.wait()
+
+        if self.__app_error:
+            print(f"Unable to send WAV file!")
+            return
+
+        wav = wave.open(file_name, "rb")
+
+        sent_frames = 0
+        total_frames = wav.getnframes()
+        sample_rate = wav.getframerate()
+        while not self.__app_quit and sent_frames < total_frames:
+            # Read 100ms worth of audio frames.
+            frames = wav.readframes(int(sample_rate / 10))
+            if len(frames) > 0:
+                self.__mic_device.write_frames(frames)
+                sent_frames += sample_rate / 10
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-m", "--meeting", required=True, help="Meeting URL")
+    parser.add_argument("-t", "--token", required=True, help="Meeting token")
+    parser.add_argument("-i", "--input", required=True, help="WAV input file")
+    parser.add_argument(
+        "-c", "--channels", type=int, default=NUM_CHANNELS, help="Number of channels"
+    )
+    parser.add_argument("-r", "--rate", type=int, default=SAMPLE_RATE, help="Sample rate")
+
+    args = parser.parse_args()
+
+    Daily.init()
+
+    app = SendWavApp(args.input, args.rate, args.channels)
+
+    try:
+        app.run(args.meeting, args.token)
+    except KeyboardInterrupt:
+        print("Ctrl-C detected. Exiting!")
+    finally:
+        app.leave()
+
+
+if __name__ == "__main__":
+    main()

examples/dynamic/hold_music/hold_music.wav

@@ -40,6 +40,7 @@
 import sys
 from pathlib import Path
 from typing import Any, Dict
+import atexit
 
 import aiohttp
 from dotenv import load_dotenv
@@ -155,6 +156,20 @@ async def mute_customer(action: dict, flow_manager: FlowManager):
         )
 
 
+async def start_hold_music(action: dict, flow_manager: FlowManager):
+    hold_music_args = flow_manager.state["hold_music_args"]
+    flow_manager.state["hold_music_process"] = await asyncio.create_subprocess_exec(
+        sys.executable,
+        str(hold_music_args["script_path"]),
+        "-m",
+        hold_music_args["room_url"],
+        "-t",
+        hold_music_args["token"],
+        "-i",
+        hold_music_args["wav_file_path"],
+    )
+
+
 async def make_customer_hear_only_hold_music(action: dict, flow_manager: FlowManager):
     """Make it so the customer only hears hold music.
 
@@ -167,15 +182,7 @@ async def make_customer_hear_only_hold_music(action: dict, flow_manager: FlowMan
         await transport.update_remote_participants(
             remote_participants={
                 customer_participant_id: {
-                    "permissions": {
-                        "canReceive": {
-                            "byUserId": {
-                                "bot": {
-                                    "customAudio": {"hold-music": True},
-                                }
-                            }
-                        }
-                    }
+                    "permissions": {"canReceive": {"byUserId": {"hold-music": True}}}
                 }
             }
         )
@@ -373,6 +380,7 @@ def create_transferring_to_human_agent_node() -> NodeConfig:
             ActionConfig(type="function", handler=mute_customer),
         ],
         post_actions=[
+            ActionConfig(type="function", handler=start_hold_music),
             ActionConfig(type="function", handler=make_customer_hear_only_hold_music),
             ActionConfig(type="function", handler=print_human_agent_join_url),
         ],
@@ -472,7 +480,6 @@ def get_human_agent_participant_id(transport: DailyTransport) -> str:
 
 async def get_customer_token(daily_rest_helper: DailyRESTHelper, room_url: str) -> str:
     """Gets a Daily token for the customer, configured with properties:
-
     {
         user_id: "customer",
         permissions: {
@@ -484,50 +491,61 @@ async def get_customer_token(daily_rest_helper: DailyRESTHelper, room_url: str)
             }
         }
     }
-
-    Note that they'll join only being able to hear the bot.
     """
     return await get_token(
         user_id="customer",
-        permissions={"canReceive": {"base": False, "byUserId": {"bot": True}}},
+        permissions={
+            "canReceive": {
+                "base": False,
+                "byUserId": {
+                    "bot": True,
+                },
+            }
+        },
         daily_rest_helper=daily_rest_helper,
         room_url=room_url,
     )
 
 
 async def get_human_agent_token(daily_rest_helper: DailyRESTHelper, room_url: str) -> str:
     """Gets a Daily token for the human agent, configured with properties:
-
     {
         user_id: "agent",
         permissions: {
             canReceive: {
                 base: false,
                 byUserId: {
-                    bot: {
-                        audio: true,
-                        customAudio: { "hold-music": false }
-                    }
+                    bot: true
                 }
             }
         }
     }
-
-    Note that they'll join only being able to hear the bot's audio (and not the hold music).
     """
     return await get_token(
         user_id="agent",
         permissions={
             "canReceive": {
                 "base": False,
-                "byUserId": {"bot": {"audio": True, "customAudio": {"hold-music": False}}},
+                "byUserId": {
+                    "bot": True,
+                },
             }
         },
         daily_rest_helper=daily_rest_helper,
         room_url=room_url,
     )
 
 
+async def get_hold_music_player_token(daily_rest_helper: DailyRESTHelper, room_url: str) -> str:
+    """Gets a Daily token for the hold music player"""
+    return await get_token(
+        user_id="hold-music",
+        permissions={},
+        daily_rest_helper=daily_rest_helper,
+        room_url=room_url,
+    )
+
+
 async def get_token(
     user_id: str, permissions: dict, daily_rest_helper: DailyRESTHelper, room_url: str
 ) -> str:
@@ -622,11 +640,11 @@ async def on_participant_left(
         ):
             # NOTE: an opportunity for refinement here is to handle the customer leaving while on
             # hold, informing the human agent if needed
-            """If all non-bot participants have left, stop the bot"""
-            non_bot_participants = {
-                k: v for k, v in transport.participants().items() if not v["info"]["isLocal"]
+            """If all human participants have left, stop the bot"""
+            human_participants = {
+                k: v for k, v in transport.participants().items() if v.get("info", {}).get("userId") in {"agent", "customer"}
             }
-            if not non_bot_participants:
+            if not human_participants:
                 await task.cancel()
 
         # Print URL for joining as customer, and store URL for joining as human agent, to be printed later
@@ -649,6 +667,27 @@ async def on_participant_left(
             f"{room_url}{'?' if '?' not in room_url else '&'}t={human_agent_token}"
         )
 
+        # Prepare hold music args
+        flow_manager.state["hold_music_args"] = {
+            "script_path": Path(__file__).parent / "hold_music" / "hold_music.py",
+            "wav_file_path": Path(__file__).parent / "hold_music" / "hold_music.wav",
+            "room_url": room_url,
+            "token": await get_hold_music_player_token(
+                daily_rest_helper=daily_rest_helper, room_url=room_url
+            ),
+        }
+
+        # Clean up hold music process at exit, if needed
+        def cleanup_hold_music_process():
+            hold_music_process = flow_manager.state.get("hold_music_process")
+            if hold_music_process:
+                try:
+                    hold_music_process.terminate()
+                except:
+                    # Exception if process already done; we don't care, it didn't hurt to try
+                    pass
+        atexit.register(cleanup_hold_music_process)
+
         # Run the pipeline
         runner = PipelineRunner()
         await runner.run(task)