diff --git a/.github/workflows/auto_deploy.yml b/.github/workflows/auto_deploy.yml deleted file mode 100644 index b7318f99c..000000000 --- a/.github/workflows/auto_deploy.yml +++ /dev/null @@ -1,157 +0,0 @@ -# This workflow will build a Java project with Maven, and cache/restore any dependencies to improve the workflow execution time -# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-maven - -# This workflow uses actions that are not certified by GitHub. -# They are provided by a third-party and are governed by -# separate terms of service, privacy policy, and support -# documentation. - -name: Java CI with Maven - -on: -# [push] - workflow_dispatch: - schedule: - - cron: '0 0 * * *' - -jobs: - build: - - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v3 - - - name: Get versions data from repo - run: wget -O maven-metadata.xml https://oss.sonatype.org/service/local/repositories/snapshots/content/io/antmedia/ant-media-server/maven-metadata.xml - - name: Install jq - run: sudo apt-get install jq -y - - name: Download war File - run: | - export LATEST_SNAPSHOT=$(grep -oP '(?<=)[^<]+' maven-metadata.xml| tail -1) - echo $LATEST_SNAPSHOT - echo "LATEST_SNAPSHOT=$LATEST_SNAPSHOT" >> $GITHUB_ENV - wget -O ConferenceCall.war "https://oss.sonatype.org/service/local/artifact/maven/redirect?r=snapshots&g=io.antmedia.webrtc&a=ConferenceCall&v=${LATEST_SNAPSHOT}&e=war" - ls -al - if [ ! -f ConferenceCall.war ]; then - echo "War file not found." - exit 1 - fi - - - name: MD5 file checksum - run: | - echo $LATEST_SNAPSHOT - wget -O ConferenceCall.md5 "https://oss.sonatype.org/service/local/artifact/maven/redirect?r=snapshots&g=io.antmedia.webrtc&a=ConferenceCall&v=${LATEST_SNAPSHOT}&e=war.md5" - local_file_md5="$(md5sum ConferenceCall.war | awk '{print $1}')" - remote_file_md5="$(cat ConferenceCall.md5)" - - if [ "$remote_file_md5" != "$local_file_md5" ]; then - echo "MD5 checksum mismatch!" - exit 1 - else - echo "MD5 checksum matches." - fi - - - name: Setup kubectl - uses: azure/setup-kubectl@v3 - with: - version: 'latest' - - - name: Create kubeconfig file - run: | - mkdir $HOME/.kube - echo "${{ secrets.KUBE_CONFIG_DATA }}" > $HOME/.kube/config - - - name: Change Replicate Set - run: | - echo "current_replica=$(kubectl get deployment ant-media-server-origin -n antmedia -o jsonpath='{.spec.replicas}')" >> $GITHUB_ENV - kubectl scale deployment ant-media-server-origin --replicas=1 -n antmedia - - - name: Login to server - run: | - response=$(curl -X POST -H "Accept: Application/json" -H "Content-Type: application/json" ${{ secrets.PRODUCTION_SERVER_URL }}/rest/v2/users/authenticate -d '{"email":"${{ secrets.USER_NAME }}","password":"${{ secrets.PASSWORD }}"}' -c cookie.txt) - success=$(echo $response | jq -r '.success') - if [ "$success" != "true" ]; then - echo "Login failed" - exit 1 - fi - - - name: Check if Conference App Exists - run: | - response=$(curl -s -H "Accept: Application/json" -H "Content-Type: application/json" "${{ secrets.PRODUCTION_SERVER_URL }}/rest/v2/applications" -b cookie.txt) - echo $response | jq . - app_exists=$(echo $response | jq -r '.applications | index("Conference")') - if [ "$app_exists" != "null" ]; then - echo "App exists, proceeding to delete it." - response=$(curl -s -X DELETE -H "Accept: Application/json" -H "Content-Type: application/json" "${{ secrets.PRODUCTION_SERVER_URL }}/rest/v2/applications/Conference" -b cookie.txt) - sleep 20 - success=$(echo $response | jq -r '.success') - if [ "$success" != "true" ]; then - echo "Conference app deletion failed" - exit 1 - fi - else - echo "App does not exist, proceeding to create a new one." - fi - - - name: Create New Conference App - id: create_app - run: | - export WAR_FILE_NAME="ConferenceCall.war" - response=$(curl -v -X PUT -H "Accept: Application/json" -H "Content-Type: multipart/form-data" -F "file=@./$WAR_FILE_NAME" "${{ secrets.PRODUCTION_SERVER_URL }}/rest/v2/applications/Conference" -b cookie.txt) - success=$(echo $response | jq -r '.success') - echo $response - if [ "$success" != "true" ]; then - echo "Conference app creation is failed" - exit 1 - fi - continue-on-error: true - - - name: Rollout restart deployment if Create Conference App failed - if: steps.create_app.outcome == 'failure' - run: | - echo "Create New App failed, performing kubectl rollout restart..." - kubectl rollout restart deployment ant-media-server-origin -n antmedia - - - name: Retry Create New Conference App - if: steps.create_app.outcome == 'failure' - run: | - export WAR_FILE_NAME="ConferenceCall.war" - response=$(curl -v -X PUT -H "Accept: Application/json" -H "Content-Type: multipart/form-data" -F "file=@./$WAR_FILE_NAME" "${{ secrets.PRODUCTION_SERVER_URL }}/rest/v2/applications/Conference" -b cookie.txt) - success=$(echo $response | jq -r '.success') - echo $response - if [ "$success" != "true" ]; then - echo "Conference app creation failed again" - exit 1 - fi - - - name: Change Settings - run: | - curl "${{ secrets.PRODUCTION_SERVER_URL }}/rest/v2/applications/settings/Conference" -b cookie.txt -o settings.json - jq '.stunServerURI = "turn:${{ secrets.PRODUCTION_TURN_URL }}" | .turnServerUsername = "${{ secrets.PRODUCTION_TURN_USERNAME }}" | .turnServerCredential = "${{ secrets.PRODUCTION_TURN_PASSWORD }}"' settings.json > updated_settings.json - response=$(curl -X POST -H "Accept: Application/json" -H "Content-Type: application/json" -d @updated_settings.json -b cookie.txt "${{ secrets.PRODUCTION_SERVER_URL }}/rest/v2/applications/settings/Conference") - success=$(echo $response | jq -r '.success') - if [ "$success" != "true" ]; then - echo "Importing setting is failed." - exit 1 - fi - - - name: Revert Replicate Set - run: | - echo $current_replica - kubectl scale deployment ant-media-server-origin --replicas=$current_replica -n antmedia - - restart_when_failed: - name: Restarts the scheduled run when it failed - runs-on: ubuntu-latest - if: github.event_name == 'schedule' && failure() - needs: build - steps: - - name: Retry the workflow - run: | - curl -i \ - -X POST \ - -H "Accept: application/vnd.github.v3+json" \ - -H "Authorization: token ${{ secrets.GIT_TOKEN }}" \ - https://api.github.com/repos/ant-media/conference-call-application/actions/workflows/auto_deploy.yml/dispatches \ - -d '{"ref": "${{ github.ref }}" }' diff --git a/.github/workflows/build-and-deploy.yml b/.github/workflows/build-and-deploy.yml index 0b4f07048..59a002dba 100644 --- a/.github/workflows/build-and-deploy.yml +++ b/.github/workflows/build-and-deploy.yml @@ -191,17 +191,6 @@ jobs: - name: Checkout repository uses: actions/checkout@v3 - - name: Set up JDK 17 - uses: actions/setup-java@v3 - with: - java-version: 17 - distribution: 'temurin' - server-id: ossrh # Value of the distributionManagement/repository/id field of the pom.xml - server-username: MAVEN_USERNAME # env variable for username in deploy - server-password: MAVEN_PASSWORD # env variable for token in deploy - gpg-private-key: ${{ secrets.MVN_GPG_KEY }} # Value of the GPG private key to import - gpg-passphrase: MAVEN_GPG_PASSPHRASE # env variable for GPG private key passphrase - - name: Restore Cached Test Tool uses: actions/cache@v3 with: @@ -218,6 +207,18 @@ jobs: unzip webrtc-load-test-tool-*.zip mkdir ~/test mv webrtc-load-test ~/test + ls -al ~/test + + - name: Set up JDK 17 + uses: actions/setup-java@v3 + with: + java-version: 17 + distribution: 'temurin' + server-id: ossrh # Value of the distributionManagement/repository/id field of the pom.xml + server-username: MAVEN_USERNAME # env variable for username in deploy + server-password: MAVEN_PASSWORD # env variable for token in deploy + gpg-private-key: ${{ secrets.MVN_GPG_KEY }} # Value of the GPG private key to import + gpg-passphrase: MAVEN_GPG_PASSPHRASE # env variable for GPG private key passphrase - name: Download circle-conferencing.war Artifact uses: actions/download-artifact@v4 @@ -298,6 +299,7 @@ jobs: - name: Run Integration Test for webinar run: | + sleep 10 cd test python3 test_main.py ${{ secrets.STAGING_SERVER_URL }} ${{ secrets.USER_NAME }} ${{ secrets.PASSWORD }} /tmp/circle-webinar.war true @@ -340,12 +342,40 @@ jobs: steps: - uses: actions/checkout@v3 + - name: Set up JDK 17 + uses: actions/setup-java@v3 + with: + java-version: 17 + distribution: 'temurin' + server-id: ossrh # Value of the distributionManagement/repository/id field of the pom.xml + server-username: MAVEN_USERNAME # env variable for username in deploy + server-password: MAVEN_PASSWORD # env variable for token in deploy + gpg-private-key: ${{ secrets.MVN_GPG_KEY }} # Value of the GPG private key to import + gpg-passphrase: MAVEN_GPG_PASSPHRASE # env variable for GPG private key passphrase + + - name: Build React application for conferencing + env: + CI: false + NODE_OPTIONS: '--max-old-space-size=4096' + run: | + cd react + mv .env.production.conferencing .env.production + sed -i "s#^REACT_APP_TURN_SERVER_URL=.*#REACT_APP_TURN_SERVER_URL=\"turn:${{ secrets.STAGING_TURN_URL }}\"#" .env.production + sed -i "s#^REACT_APP_TURN_SERVER_USERNAME=.*#REACT_APP_TURN_SERVER_USERNAME=\"${{ secrets.STAGING_TURN_USERNAME }}\"#" .env.production + sed -i "s#^REACT_APP_TURN_SERVER_CREDENTIAL=.*#REACT_APP_TURN_SERVER_CREDENTIAL=\"${{ secrets.STAGING_TURN_PASSWORD }}\"#" .env.production + npm install + npm run build + cd .. + rm -r webapp/src/main/webapp/static/* + cp -a react/build/. webapp/src/main/webapp + - name: Publish to Maven Central run: | cd webapp ls -alh ls -alh target/ mvn -e deploy -DskipTests --quiet --settings ../mvn-settings.xml + sleep 60 env: MAVEN_USERNAME: ${{ secrets.MVN_USERNAME }} MAVEN_PASSWORD: ${{ secrets.MVN_PASSWORD }} diff --git a/react/.env.production b/react/.env.production index 4c39323b1..983d5469d 100644 --- a/react/.env.production +++ b/react/.env.production @@ -54,10 +54,12 @@ REACT_APP_LAYOUT_OTHERS_CARD_VISIBILITY=true REACT_APP_TIME_ZONE_LIVE_TEXT_VISIBILITY=true # Video Overlay configurations -REACT_APP_VIDEO_OVERLAY_ADMIN_MODE_ENABLED=true +REACT_APP_VIDEO_OVERLAY_ADMIN_MODE_ENABLED=false +REACT_APP_VIDEO_OVERLAY_ADMIN_CAMERA_CONTROL_ENABLED=false # Participant Tab configurations REACT_APP_PARTICIPANT_TAB_ADMIN_MODE_ENABLED=true +REACT_APP_PARTICIPANT_TAB_MUTE_PARTICIPANT_BUTTON_ENABLED=true # Meeting Recording configuration REACT_APP_RECORDING_MANAGED_BY_ADMIN=false @@ -68,6 +70,9 @@ REACT_APP_RECORDING_MANAGED_BY_ADMIN=false # Speed Test configurations REACT_APP_SPEED_TEST_BEFORE_JOINING_THE_ROOM=false +# Virtual Background configurations +REACT_APP_VIRTUAL_BACKGROUND_IMAGES="https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background0.png,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background1.jpg,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background2.jpg,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background3.jpg,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background4.jpg,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background5.jpg,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background7.jpg" + # URL configurations REACT_APP_FOOTER_LOGO_ON_CLICK_URL="https://antmedia.io/circle" REACT_APP_REPORT_PROBLEM_URL="https://github.com/ant-media/conference-call-application/issues" \ No newline at end of file diff --git a/react/.env.production.webinar b/react/.env.production.webinar index a0a40ed12..41eaf94e7 100644 --- a/react/.env.production.webinar +++ b/react/.env.production.webinar @@ -55,12 +55,14 @@ REACT_APP_TIME_ZONE_LIVE_TEXT_VISIBILITY=true # Video Overlay configurations REACT_APP_VIDEO_OVERLAY_ADMIN_MODE_ENABLED=true +REACT_APP_VIDEO_OVERLAY_ADMIN_CAMERA_CONTROL_ENABLED=false # Speed Test configurations REACT_APP_SPEED_TEST_BEFORE_JOINING_THE_ROOM=true # Participant Tab configurations REACT_APP_PARTICIPANT_TAB_ADMIN_MODE_ENABLED=true +REACT_APP_PARTICIPANT_TAB_MUTE_PARTICIPANT_BUTTON_ENABLED=true # Meeting Recording configuration REACT_APP_RECORDING_MANAGED_BY_ADMIN=true @@ -71,6 +73,9 @@ REACT_APP_FORCE_THEME="white" # Speed Test configurations REACT_APP_SPEED_TEST_BEFORE_JOINING_THE_ROOM=true +# Virtual Background configurations +REACT_APP_VIRTUAL_BACKGROUND_IMAGES="https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background0.png,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background1.jpg,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background2.jpg,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background3.jpg,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background4.jpg,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background5.jpg,https://raw.githubusercontent.com/ant-media/conference-call-application/main/static/virtualBackgroundImages/virtual-background7.jpg" + # URL configurations REACT_APP_FOOTER_LOGO_ON_CLICK_URL="" REACT_APP_REPORT_PROBLEM_URL="" diff --git a/react/package-lock.json b/react/package-lock.json index 54c7a6cfe..c1951474d 100644 --- a/react/package-lock.json +++ b/react/package-lock.json @@ -8,7 +8,7 @@ "name": "antmedia-cra", "version": "2.12.0-SNAPSHOT", "dependencies": { - "@antmedia/webrtc_adaptor": "^2.12.0-SNAPSHOT-2024-Oct-19-07-47", + "@antmedia/webrtc_adaptor": "2.12.0-SNAPSHOT-2024-Nov-29-04-11", "@charkour/react-reactions": "^0.11.0", "@emotion/react": "^11.13.3", "@emotion/styled": "^11.13.0", @@ -92,10 +92,9 @@ } }, "node_modules/@antmedia/webrtc_adaptor": { - "version": "2.12.0-SNAPSHOT-2024-Sep-10-07-00", - "resolved": "https://registry.npmjs.org/@antmedia/webrtc_adaptor/-/webrtc_adaptor-2.12.0-SNAPSHOT-2024-Sep-10-07-00.tgz", - "integrity": "sha512-vvQiJ4ib+3tIylun+6bKHybGCs0ujUdXt03pNuvZ//zzWZlAUjcoceZTmcTt2Wr8CcMQK/mKDO/93b5Jf6bnIw==", - "license": "ISC", + "version": "2.12.0-SNAPSHOT-2024-Nov-29-04-11", + "resolved": "https://registry.npmjs.org/@antmedia/webrtc_adaptor/-/webrtc_adaptor-2.12.0-SNAPSHOT-2024-Nov-29-04-11.tgz", + "integrity": "sha512-Og0qRIuby0jtDMsDJvsKGSnIaFS9+IajeqHDEQ+YhJTvoc9yQIUTh8+1m2GN1Nas8pY7qNRImJWlSDKorjwMrQ==", "dependencies": { "@mediapipe/selfie_segmentation": "^0.1.1675465747", "url": "^0.11.1" diff --git a/react/package.json b/react/package.json index 29fd71c2a..c187abab4 100644 --- a/react/package.json +++ b/react/package.json @@ -4,7 +4,7 @@ "private": true, "homepage": ".", "dependencies": { - "@antmedia/webrtc_adaptor": "^2.12.0-SNAPSHOT-2024-Oct-19-07-47", + "@antmedia/webrtc_adaptor": "2.12.0-SNAPSHOT-2024-Nov-29-04-11", "@charkour/react-reactions": "^0.11.0", "@emotion/react": "^11.13.3", "@emotion/styled": "^11.13.0", diff --git a/react/public/speed-test-sample-video.mp4 b/react/public/speed-test-sample-video.mp4 deleted file mode 100644 index ed139d6d5..000000000 Binary files a/react/public/speed-test-sample-video.mp4 and /dev/null differ diff --git a/react/src/Components/Cards/VideoCard.js b/react/src/Components/Cards/VideoCard.js index 82842170d..e51876164 100644 --- a/react/src/Components/Cards/VideoCard.js +++ b/react/src/Components/Cards/VideoCard.js @@ -1,118 +1,156 @@ -import React, { useCallback, useContext, useEffect } from "react"; +import React, { useCallback, useContext, useEffect, useState, useRef } from "react"; import { alpha, styled } from "@mui/material/styles"; import { ConferenceContext } from "pages/AntMedia"; import DummyCard from "./DummyCard"; import { Grid, Typography, useTheme, Box, Tooltip, Fab } from "@mui/material"; import { SvgIcon } from "../SvgIcon"; import { useTranslation } from "react-i18next"; -import { isMobile, isTablet } from 'react-device-detect'; +import { isMobile, isTablet } from "react-device-detect"; +import {parseMetaData} from "../../utils"; const CustomizedVideo = styled("video")({ - borderRadius: 4, - width: "100%", - height: "100%", - objectPosition: "center", - backgroundColor: "transparent", + borderRadius: 4, + width: "100%", + height: "100%", + objectPosition: "center", + backgroundColor: "transparent", }); + const CustomizedBox = styled(Box)(({ theme }) => ({ - backgroundColor: alpha(theme.palette.gray[90], 0.3), + backgroundColor: alpha(theme.palette.gray[90], 0.3), })); function VideoCard(props) { - const conference = useContext(ConferenceContext); - - const { t } = useTranslation(); - const [displayHover, setDisplayHover] = React.useState(false); - const theme = useTheme(); - - const cardBtnStyle = { - display: "flex", - justifyContent: "center", - alignItems: "center", - width: { xs: "6vw", md: 32 }, - height: { xs: "6vw", md: 32 }, - borderRadius: "50%", - position: "relative", - }; - - const refVideo = useCallback( (node) => { - if (node && props.trackAssignment.track) { - node.srcObject = new MediaStream([props.trackAssignment.track]); - node.play().then(()=> {}).catch((e) => { console.log("play failed because ", e)}); - } - }, - [props.trackAssignment.track] - ); - - let useAvatar = true; - if(props?.trackAssignment.isMine) { - useAvatar = conference?.isMyCamTurnedOff; - } - else if (props.trackAssignment.track?.kind === "video") { - let broadcastObject = conference?.allParticipants[props?.trackAssignment.streamId]; - let metaData = broadcastObject?.metaData; - useAvatar = !parseMetaDataAndGetIsCameraOn(metaData) && !parseMetaDataAndGetIsScreenShared(metaData); - } - - function isJsonString(str) { - try { - JSON.parse(str); - } catch (e) { - return false; - } - return true; - } - - function parseMetaDataAndGetIsCameraOn(metaData) { - if (!metaData) return false; - return (isJsonString(metaData)) ? JSON.parse(metaData).isCameraOn : false; - } - - function parseMetaDataAndGetIsScreenShared(metaData) { - if (!metaData) return false; - return (isJsonString(metaData)) ? JSON.parse(metaData).isScreenShared : false; - } - - function parseMetaDataAndGetIsMicMuted(metaData) { - if (!metaData) return true; - return (isJsonString(metaData)) ? JSON.parse(metaData).isMicMuted : true; - } - - const micMuted = (props?.trackAssignment.isMine) ? conference?.isMyMicMuted : parseMetaDataAndGetIsMicMuted(conference?.allParticipants[props?.trackAssignment.streamId]?.metaData); + const conference = useContext(ConferenceContext); + const { t } = useTranslation(); + const [displayHover, setDisplayHover] = useState(false); + const [isTalking, setIsTalking] = useState(false); + const theme = useTheme(); + const timeoutRef = useRef(null); + + const refVideo = useCallback((node) => { + if (node && props.trackAssignment.track) { + node.srcObject = new MediaStream([props.trackAssignment.track]); + node.play().catch((e) => console.error("Video playback failed:", e)); + } + }, [props.trackAssignment.track]); + + const cardBtnStyle = { + display: "flex", + justifyContent: "center", + alignItems: "center", + width: { xs: "6vw", md: 32 }, + height: { xs: "6vw", md: 32 }, + borderRadius: "50%", + position: "relative", + }; + + const isMine = props.trackAssignment?.isMine; + const isVideoTrack = props.trackAssignment.track?.kind === "video"; + + const micMuted = isMine + ? conference?.isMyMicMuted + : parseMetaData( + conference?.allParticipants?.[props.trackAssignment.streamId]?.metaData, + "isMicMuted" + ); + + const useAvatar = isMine + ? conference?.isMyCamTurnedOff + : !parseMetaData( + conference?.allParticipants?.[props.trackAssignment.streamId]?.metaData, + "isCameraOn" + ) && + !parseMetaData( + conference?.allParticipants?.[props.trackAssignment.streamId]?.metaData, + "isScreenShared" + ); + + useEffect(() => { + if (props?.trackAssignment.isMine && conference.isPublished && !conference.isPlayOnly) { + conference.setAudioLevelListener((value) => { + // sounds under 0.01 are probably background noise + if (value >= 0.01) { + if (isTalking === false) setIsTalking(true); + clearInterval(timeoutRef.current); + timeoutRef.current = setTimeout(() => { + setIsTalking(false); + }, 1500); + } + }, 1000); + } + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [conference.isPublished]); + + const OverlayButton = ({ title, icon, color, onClick }) => ( + + + + + + ); - const [isTalking, setIsTalking] = React.useState(false); + const AdministrativeButtons = ({ micMuted, useAvatar }) => { + const handleToggleMic = () => { + const participant = { + streamId: props.trackAssignment.streamId, + streamName: props.name, + }; + conference?.setParticipantIdMuted(participant); + micMuted + ? conference?.turnOnYourMicNotification(participant.streamId) + : conference?.turnOffYourMicNotification(participant.streamId); + }; + + const handleToggleCam = () => { + const participant = { + streamId: props.trackAssignment.streamId, + streamName: props.name, + }; + conference?.setParticipantIdMuted(participant); + conference?.turnOffYourCamNotification(participant.streamId); + }; + + return ( + <> + {(!useAvatar && process.env.REACT_APP_VIDEO_OVERLAY_ADMIN_MODE_ENABLED === "true") && ( + + )} + + + ); + }; + + const PinButton = ({ }) => ( + conference.pinVideo(props.trackAssignment.streamId)} + /> + ); + const renderOverlayButtons = () => { + if (props.hidePin) return null; - const timeoutRef = React.useRef(null); + const isAdminMode = process.env.REACT_APP_VIDEO_OVERLAY_ADMIN_MODE_ENABLED === "true"; + const isAdministrativeButtonsVisible = + !props?.trackAssignment.isMine && (!isAdminMode || conference.isAdmin); - const mirrorView = props?.trackAssignment.isMine; - //const isScreenSharing = - // conference?.isScreenShared || - // conference?.screenSharedVideoId === props?.trackAssignment.streamId; - //conference?.isScreenShared means am i sharing my screen - //conference?.screenSharedVideoId === props?.trackAssignment.streamId means is someone else sharing their screen - useEffect(() => { - if (props?.trackAssignment.isMine && conference.isPublished && !conference.isPlayOnly) { - conference.setAudioLevelListener((value) => { - // sounds under 0.01 are probably background noise - if (value >= 0.01) { - if (isTalking === false) setIsTalking(true); - clearInterval(timeoutRef.current); - timeoutRef.current = setTimeout(() => { - setIsTalking(false); - }, 1500); - } - }, 1000); - } - // eslint-disable-next-line react-hooks/exhaustive-deps - }, [conference.isPublished]); - - const overlayButtonsGroup = () => { - if (process.env.REACT_APP_VIDEO_OVERLAY_ADMIN_MODE_ENABLED === "true") { - return (!props.hidePin && ( + return ( - - - {(!isMobile) && (!isTablet) ? - - { - conference.pinVideo(props.trackAssignment.streamId); - }} - color="primary" - aria-label={props.pinned ? t("unpin") : t("pin")} - size="small" - > - - - - : null } - - { !props?.trackAssignment.isMine && conference.isAdmin && conference.isAdmin === true ? - - {!useAvatar ? - - { - let participant = {}; - participant.streamId=props.trackAssignment.streamId; - participant.streamName=props.name; - conference?.setParticipantIdMuted(participant); - conference?.turnOffYourCamNotification(participant.streamId); - }} - color="primary" - aria-label="turn-off-camera" - size="small" - > - - - - : - - - - - - } - - : null } - - {(!props?.trackAssignment.isMine && conference.isAdmin && conference.isAdmin === true) ? - - {!micMuted ? - - { - let participant = {}; - participant.streamId=props.trackAssignment.streamId; - participant.streamName=props.name; - conference?.setParticipantIdMuted(participant); - conference?.turnOffYourMicNotification(participant.streamId); - }} - color="primary" - aria-label="mute" - size="small" - > - - - - : - { - let participant = {}; - participant.streamId=props.trackAssignment.streamId; - participant.streamName=props.name; - conference?.setParticipantIdMuted(participant); - conference?.turnOnYourMicNotification(participant.streamId); - }} - color="error" - aria-label="unmute" - size="small" - > - - - } - - : null } + + + {!isMobile && !isTablet && } + {isAdministrativeButtonsVisible && } - )) - } else { - return (!props.hidePin && ( - - - - {(!isMobile) && (!isTablet) ? - - {conference.pinVideo(props.trackAssignment.streamId);}} - color="primary" - aria-label={props.pinned ? "unpin" : "pin"} - size="small" - > - - - - : null } + ); + }; - {(!props?.trackAssignment.isMine && !micMuted) ? - - - { - let participant = {}; - participant.streamId=props.trackAssignment.streamId; - participant.streamName=props.name; - conference?.setParticipantIdMuted(participant); - conference?.turnOffYourMicNotification(participant.streamId); - conference?.setMuteParticipantDialogOpen(true); + const renderAvatarOrPlayer = () => ( + <> + {useAvatar ? ( + + + + ) : ( + - - - - - : null} - - - - )) - }} - const avatarOrPlayer = () => { - return ( - <> - - - + > + + + )} + + ); + const renderParticipantStatus = () => ( - - - - ) - } - - const overlayParticipantStatus = () => { - return ( - - {micMuted && ( - - - - - - - - )} - {/* - - - + {micMuted && ( + + + + + + + + )} - */} - {props.pinned && ( - - - - - - - - )} - - ); - } - - const overlayVideoTitle = () => { - return ( - props.name && ( -
- - {props.name}{" "} - {process.env.NODE_ENV === "development" - ? `${props?.trackAssignment.isMine - ? props.trackAssignment.streamId + - " " + - conference.streamName - : props.trackAssignment.streamId + " " + props.trackAssignment.track?.id - }` - : ""} - -
- ) ); - } - const isTalkingFrame = () => { - return ( -
- ); - } - - const setLocalVideo = () => { - let tempLocalVideo = document.getElementById((typeof conference?.publishStreamId === "undefined")? "localVideo" : conference?.publishStreamId); - if(props?.trackAssignment.isMine && conference.localVideo !== tempLocalVideo) { - conference?.localVideoCreate(tempLocalVideo); + const setLocalVideo = () => { + let tempLocalVideo = document.getElementById((typeof conference?.publishStreamId === "undefined")? "localVideo" : conference?.publishStreamId); + if(props.trackAssignment.isMine && conference.localVideo !== tempLocalVideo) { + conference?.localVideoCreate(tempLocalVideo); + } } - }; - return props?.trackAssignment.isMine || props.trackAssignment.track?.kind !== "audio" ? ( - <> - setDisplayHover(true)} - onMouseLeave={(e) => setDisplayHover(false)} - > + const overlayVideoTitle = () => { + return ( + props.name && ( +
+ + {props.name}{" "} + {process.env.NODE_ENV === "development" + ? `${props?.trackAssignment.isMine + ? props.trackAssignment.streamId + + " " + + conference.streamName + : props.trackAssignment.streamId + " " + props.trackAssignment.track?.id + }` + : ""} + +
+ ) + ); + } - {overlayButtonsGroup()} + const isTalkingFrame = () => { + return ( +
+ ); + } -
+ setDisplayHover(true)} + onMouseLeave={() => setDisplayHover(false)} > - {avatarOrPlayer()} - - {setLocalVideo()} - - {overlayParticipantStatus()} - - {isTalkingFrame()} - - {overlayVideoTitle()} - -
- - - ) : ( - //for audio tracks - <> - - - ); + {renderOverlayButtons()} +
+ {renderAvatarOrPlayer()} + {renderParticipantStatus()} + {setLocalVideo()} + {isTalkingFrame()} + {overlayVideoTitle()} +
+ + + ) : ( + //for audio tracks + <> + + + ); }; export default VideoCard; diff --git a/react/src/Components/EffectsTab.js b/react/src/Components/EffectsTab.js index b9f7ee7b9..4f263792c 100644 --- a/react/src/Components/EffectsTab.js +++ b/react/src/Components/EffectsTab.js @@ -5,7 +5,6 @@ import { SvgIcon } from "./SvgIcon"; import { ConferenceContext } from "pages/AntMedia"; import {CustomizedBtn} from "./Footer/Components/MicButton"; import {useTheme} from "@mui/material"; -import virtualBackgroundImageData from 'virtualBackground.json'; import {useSnackbar} from "notistack"; import {useTranslation} from "react-i18next"; @@ -51,8 +50,9 @@ function EffectsTab() { position: 'relative' }} id="custom-virtual-background-button" + data-testid="custom-virtual-background-button" onClick={(e) => { - conference.setAndEnableVirtualBackgroundImage(imageSrc); + conference.setVirtualBackgroundImage(imageSrc); }} > { + let virtualBackgroundImageData = []; + + if (process.env.REACT_APP_VIRTUAL_BACKGROUND_IMAGES !== undefined && process.env.REACT_APP_VIRTUAL_BACKGROUND_IMAGES !== null) { + virtualBackgroundImageData = process.env.REACT_APP_VIRTUAL_BACKGROUND_IMAGES.split(','); + } + const images = []; let imageIndex = 0; - for (let i = 0; i < virtualBackgroundImageData.virtualBackgroundImages.length; i++) { + for (let i = 0; i < virtualBackgroundImageData.length; i++) { images.push( - getVirtualBackgroundButton(virtualBackgroundImageData.virtualBackgroundImages[i], "image"+imageIndex, imageIndex, false) + getVirtualBackgroundButton(virtualBackgroundImageData[i], "image"+imageIndex, imageIndex, false) ); ++imageIndex; } diff --git a/react/src/Components/Footer/Components/ParticipantListButton.js b/react/src/Components/Footer/Components/ParticipantListButton.js index d9c4a62ea..b9f35191d 100644 --- a/react/src/Components/Footer/Components/ParticipantListButton.js +++ b/react/src/Components/Footer/Components/ParticipantListButton.js @@ -38,7 +38,7 @@ function ParticipantListButton({ footer }) { > {/* eslint-disable-next-line jsx-a11y/anchor-is-valid */} - {Object.keys(conference.allParticipants).length} + {conference.participantCount} ); diff --git a/react/src/Components/ParticipantTab.js b/react/src/Components/ParticipantTab.js index 0fe94661c..4ac7fcc96 100644 --- a/react/src/Components/ParticipantTab.js +++ b/react/src/Components/ParticipantTab.js @@ -6,8 +6,9 @@ import Button from "@mui/material/Button"; import {styled, useTheme} from "@mui/material/styles"; import { SvgIcon } from "./SvgIcon"; import { ConferenceContext } from "pages/AntMedia"; -import {CircularProgress} from "@mui/material"; +import {CircularProgress, Pagination} from "@mui/material"; import {WebinarRoles} from "../WebinarRoles"; +import {parseMetaData} from "../utils"; const ParticipantName = styled(Typography)(({ theme }) => ({ color: theme.palette.textColor, @@ -25,9 +26,51 @@ function ParticipantTab(props) { const conference = React.useContext(ConferenceContext); const theme = useTheme(); + const paginationUpdate = (event, value) => { + conference?.updateAllParticipantsPagination(value); + } + + const handleToggleMic = (isMicMuted, streamId, streamName) => { + if (streamId === conference?.publishStreamId && !conference?.isMyMicMuted) { + conference?.muteLocalMic(); + return; + } + + const participant = { + streamId: streamId, + streamName: streamName, + }; + conference?.setParticipantIdMuted(participant); + if (!isMicMuted) { + conference?.turnOffYourMicNotification(participant.streamId); + } + }; + + const getMuteParticipantButton = (streamId) => { + let micMuted = false; + if (streamId === conference?.publishStreamId) { + micMuted = conference?.isMyMicMuted; + } else { + micMuted =parseMetaData(conference.pagedParticipants[streamId]?.metaData, "isMicMuted"); + } + let name = conference.pagedParticipants[streamId]?.name; + + return ( + { handleToggleMic(micMuted, streamId, name) } + } + > + + + ) + } + const getAdminButtons = (streamId, assignedVideoCardId) => { let publishStreamId = (streamId === "localVideo") ? conference.publishStreamId : streamId; - let role = conference.allParticipants[publishStreamId]?.role; + let role = conference.pagedParticipants[publishStreamId]?.role; return (
@@ -47,7 +90,7 @@ function ParticipantTab(props) { { ( role === WebinarRoles.Host || role === WebinarRoles.Speaker || role === WebinarRoles.TempListener ) && conference?.isAdmin === true ?( { conference?.makeParticipantPresenter(publishStreamId) } @@ -97,7 +140,7 @@ function ParticipantTab(props) {
- {(typeof conference.allParticipants[streamId]?.isPinned !== "undefined") && (conference.allParticipants[streamId]?.isPinned === true) ? ( + {(typeof conference.pagedParticipants[streamId]?.isPinned !== "undefined") && (conference.pagedParticipants[streamId]?.isPinned === true) ? (
@@ -139,20 +185,32 @@ function ParticipantTab(props) { variant="body2" style={{marginLeft: 4, fontWeight: 500}} > - {Object.keys(conference.allParticipants).length} + {conference?.participantCount} - {conference.isPlayOnly === false ? getParticipantItem(conference.publishStreamId, "You") : ""} - {Object.entries(conference.allParticipants).map(([streamId, broadcastObject]) => { + {Object.entries(conference.pagedParticipants).map(([streamId, broadcastObject]) => { if (conference.publishStreamId !== streamId) { - var assignedVideoCardId = conference?.videoTrackAssignments?.find(vta => vta.streamId === streamId)?.videoLabel; + let assignedVideoCardId = conference?.videoTrackAssignments?.find(vta => vta.streamId === streamId)?.videoLabel; return getParticipantItem(streamId, broadcastObject.name, assignedVideoCardId); } else { - return ""; + return getParticipantItem(conference.publishStreamId, "You"); } })} + {/* Pagination Controls */} + + + ); diff --git a/react/src/__tests__/Components/EffectsTab.test.js b/react/src/__tests__/Components/EffectsTab.test.js new file mode 100644 index 000000000..b47e0728c --- /dev/null +++ b/react/src/__tests__/Components/EffectsTab.test.js @@ -0,0 +1,85 @@ +// src/EffectsTab.test.js +import React from 'react'; +import { render } from '@testing-library/react'; +import { ConferenceContext } from 'pages/AntMedia'; +import EffectsTab from "../../Components/EffectsTab"; +import theme from "../../styles/theme"; +import {ThemeList} from "../../styles/themeList"; +import {ThemeProvider} from "@mui/material"; + +const mockOpfsRoot = { + values: jest.fn(() => ({ + [Symbol.asyncIterator]: async function* () { + yield { name: 'file1.txt' }; + yield { name: 'file2.txt' }; + }, + })), +}; + +const contextValue = { + allParticipants: { + 'test-stream-id': { + role: 'host', + participantID: 'test-participant-id', + streamID: 'test-stream-id', + videoTrack: 'test-video-track', + audioTrack: 'test-audio-track', + videoLabel: 'test-video-label', + }, + }, + publishStreamId: 'test-stream-id', + setVirtualBackgroundImage: jest.fn(), +}; + +// Mock the useContext hook +jest.mock('react', () => ({ + ...jest.requireActual('react'), + useContext: jest.fn(), +})); + +describe('Effects Tab Component', () => { + + beforeEach(() => { + // Reset the mock implementation before each test + jest.clearAllMocks(); + + Object.defineProperty(navigator, 'storage', { + value: { + getDirectory: jest.fn().mockResolvedValue(mockOpfsRoot), + }, + writable: true, + }); + + React.useContext.mockImplementation(input => { + if (input === ConferenceContext) { + return contextValue; + } + return jest.requireActual('react').useContext(input); + }); + }); + + it('renders without crashing', () => { + render( + + + + ); + }); + + describe('getBackgroundImages', () => { + it('returns an empty array when no environment variable or custom images are provided', () => { + process.env.REACT_APP_VIRTUAL_BACKGROUND_IMAGES = undefined; + const {getByTestId} = render( + + + + ); + let customVirtualBackgroundButton = getByTestId('custom-virtual-background-button'); + customVirtualBackgroundButton.click(); + expect(contextValue.setVirtualBackgroundImage).toHaveBeenCalled(); + }); + + + }); + +}); diff --git a/react/src/__tests__/Components/Footer/Components/EndCallButton.test.js b/react/src/__tests__/Components/Footer/Components/EndCallButton.test.js new file mode 100644 index 000000000..346a81f4e --- /dev/null +++ b/react/src/__tests__/Components/Footer/Components/EndCallButton.test.js @@ -0,0 +1,39 @@ +// src/EndCallButton.test.js +import React from 'react'; +import { render } from '@testing-library/react'; +import { ConferenceContext } from 'pages/AntMedia'; +import EndCallButton from "../../../../Components/Footer/Components/EndCallButton"; + +// Mock the context value +const contextValue = { + setLeftTheRoom: jest.fn(), +}; + +// Mock the useContext hook +jest.mock('react', () => ({ + ...jest.requireActual('react'), + useContext: jest.fn(), +})); + +describe('End Call Button Component', () => { + + beforeEach(() => { + // Reset the mock implementation before each test + jest.clearAllMocks(); + + React.useContext.mockImplementation(input => { + if (input === ConferenceContext) { + return contextValue; + } + return jest.requireActual('react').useContext(input); + }); + }); + + + it('renders without crashing', () => { + render( + + ); + }); + +}); diff --git a/react/src/__tests__/Components/Footer/Components/FakeParticipantButton.test.js b/react/src/__tests__/Components/Footer/Components/FakeParticipantButton.test.js new file mode 100644 index 000000000..3fba95290 --- /dev/null +++ b/react/src/__tests__/Components/Footer/Components/FakeParticipantButton.test.js @@ -0,0 +1,39 @@ +// src/FakeParticipantButton.test.js +import React from 'react'; +import { render } from '@testing-library/react'; +import { ConferenceContext } from 'pages/AntMedia'; +import FakeParticipantButton from "../../../../Components/Footer/Components/FakeParticipantButton"; + +// Mock the context value +const contextValue = { + setLeftTheRoom: jest.fn(), +}; + +// Mock the useContext hook +jest.mock('react', () => ({ + ...jest.requireActual('react'), + useContext: jest.fn(), +})); + +describe('Fake Participant Button Component', () => { + + beforeEach(() => { + // Reset the mock implementation before each test + jest.clearAllMocks(); + + React.useContext.mockImplementation(input => { + if (input === ConferenceContext) { + return contextValue; + } + return jest.requireActual('react').useContext(input); + }); + }); + + + it('renders without crashing', () => { + render( + + ); + }); + +}); diff --git a/react/src/__tests__/Components/Footer/Components/ParticipantListButton.test.js b/react/src/__tests__/Components/Footer/Components/ParticipantListButton.test.js index 9907f5996..eb3a35a6d 100644 --- a/react/src/__tests__/Components/Footer/Components/ParticipantListButton.test.js +++ b/react/src/__tests__/Components/Footer/Components/ParticipantListButton.test.js @@ -1,6 +1,6 @@ // src/Button.test.js import React from 'react'; -import { render } from '@testing-library/react'; +import {act, render} from '@testing-library/react'; import { ConferenceContext } from 'pages/AntMedia'; import ParticipantListButton from 'Components/Footer/Components/ParticipantListButton'; import { random } from 'lodash'; @@ -8,6 +8,8 @@ import { random } from 'lodash'; // Mock the context value const contextValue = { allParticipants: {}, + participantCount: 0, + setParticipantCount: jest.fn() }; // Mock the useContext hook @@ -37,11 +39,14 @@ describe('ParticipantList Button Component', () => { ); }); - it('check the count on button', () => { + it('check the count on button', async () => { var noOfParticipants = random(1, 10); - for (let i = 0; i < noOfParticipants; i++) { - contextValue.allParticipants[`k${i}`] = `v${i}`; - } + + await act(()=> + { + contextValue.setParticipantCount(noOfParticipants) + contextValue.participantCount = noOfParticipants; + }); const { container, getByText, getByRole } = render( diff --git a/react/src/__tests__/Components/ParticipantTab.test.js b/react/src/__tests__/Components/ParticipantTab.test.js index 8cff6c6fc..f60984c00 100644 --- a/react/src/__tests__/Components/ParticipantTab.test.js +++ b/react/src/__tests__/Components/ParticipantTab.test.js @@ -21,13 +21,63 @@ const contextValue = { audioTrack: 'test-audio-track', videoLabel: 'test-video-label', }, + 'test-stream-id-2': { + role: 'host', + participantID: 'test-participant-id-2', + streamID: 'test-stream-id-2', + videoTrack: 'test-video-track-2', + audioTrack: 'test-audio-track-2', + videoLabel: 'test-video-label-2', + metaData: { + isMuted: false + } + } }, publishStreamId: 'test-stream-id', pinVideo: jest.fn(), makeParticipantPresenter: jest.fn(), + pagedParticipants: { + 'test-stream-id': { + role: 'host', + participantID: 'test-participant-id', + streamID: 'test-stream-id', + videoTrack: 'test-video-track', + audioTrack: 'test-audio-track', + videoLabel: 'test-video-label', + }, + 'test-stream-id-2': { + role: 'host', + participantID: 'test-participant-id-2', + streamID: 'test-stream-id-2', + videoTrack: 'test-video-track-2', + audioTrack: 'test-audio-track-2', + videoLabel: 'test-video-label-2', + metaData: { + isMuted: false + } + } + }, isAdmin: true, isPlayOnly: false, - videoTrackAssignments: [{streamID: 'test-stream-id', participantID: 'test-participant-id', videoTrack: 'test-video-track', audioTrack: 'test-audio-track', videoLabel: 'test-video-label'}], + videoTrackAssignments: [ + {streamID: 'test-stream-id', participantID: 'test-participant-id', videoTrack: 'test-video-track', audioTrack: 'test-audio-track', videoLabel: 'test-video-label'}, + {streamID: 'test-stream-id-2', participantID: 'test-participant-id-2', videoTrack: 'test-video-track-2', audioTrack: 'test-audio-track-2', videoLabel: 'test-video-label-2'} + ], + globals: { + maxVideoTrackCount: 6, + desiredTileCount: 6, + trackEvents: [], + participantListPagination: { + currentPage: 1, + pageSize: 15, + totalPage: 1, + startIndex: 0, + endIndex: 15 + } + }, + muteLocalMic: jest.fn(), + turnOffYourMicNotification: jest.fn(), + setParticipantIdMuted: jest.fn(), }; // Mock the useContext hook @@ -94,5 +144,41 @@ describe('ParticipantTab Component', () => { const presenterButton = getByTestId('add-presenter-test-stream-id'); expect(presenterButton).toBeInTheDocument(); }); + + it('check muteLocalMic called in getMuteParticipantButton', () => { + contextValue.isAdmin = true; + process.env.REACT_APP_PARTICIPANT_TAB_MUTE_PARTICIPANT_BUTTON_ENABLED=true + + const { getByTestId } = render( + + + + ); + const micToggleParticipant = getByTestId('mic-toggle-participant-test-stream-id'); + expect(micToggleParticipant).toBeInTheDocument(); + + micToggleParticipant.click(); + expect(contextValue.muteLocalMic).toHaveBeenCalled(); + expect(contextValue.setParticipantIdMuted).not.toHaveBeenCalled(); + expect(contextValue.turnOffYourMicNotification).not.toHaveBeenCalled(); + }); + + it('check turnOffYourMicNotification called in getMuteParticipantButton', () => { + contextValue.isAdmin = true; + process.env.REACT_APP_PARTICIPANT_TAB_MUTE_PARTICIPANT_BUTTON_ENABLED=true + + const { getByTestId } = render( + + + + ); + const micToggleParticipant = getByTestId('mic-toggle-participant-test-stream-id-2'); + expect(micToggleParticipant).toBeInTheDocument(); + + micToggleParticipant.click(); + expect(contextValue.muteLocalMic).not.toHaveBeenCalled(); + expect(contextValue.setParticipantIdMuted).toHaveBeenCalled(); + expect(contextValue.turnOffYourMicNotification).toHaveBeenCalled(); + }); }); diff --git a/react/src/__tests__/pages/AntMedia.test.js b/react/src/__tests__/pages/AntMedia.test.js index f6eb3ede8..03d61009b 100644 --- a/react/src/__tests__/pages/AntMedia.test.js +++ b/react/src/__tests__/pages/AntMedia.test.js @@ -10,6 +10,7 @@ import {ThemeList} from "styles/themeList"; import theme from "styles/theme"; import { times } from 'lodash'; import { useParams } from 'react-router-dom'; +import {VideoEffect} from "@antmedia/webrtc_adaptor"; var webRTCAdaptorConstructor, webRTCAdaptorScreenConstructor, webRTCAdaptorPublishSpeedTestPlayOnlyConstructor, webRTCAdaptorPublishSpeedTestConstructor, webRTCAdaptorPlaySpeedTestConstructor; var currentConference; @@ -80,10 +81,13 @@ jest.mock('@antmedia/webrtc_adaptor', () => ({ createSpeedTestForPlayWebRtcAdaptor: jest.fn(), requestVideoTrackAssignments: jest.fn(), stopSpeedTest: jest.fn().mockImplementation(() => console.log('stopSpeedTest')), - getSubtracks: jest.fn(), closeStream: jest.fn(), closeWebSocket: jest.fn(), - playStats: {} + playStats: {}, + enableEffect: jest.fn(), + setSelectedVideoEffect: jest.fn(), + setBlurEffectRange: jest.fn(), + getSubtrackCount: jest.fn(), } for (var key in params) { @@ -1304,7 +1308,7 @@ describe('AntMedia Component', () => { }; const weak_msg = "Poor Network Connection Warning:Network connection is weak. You may encounter connection drop!"; - const unstable_msg = "Poor Network Connection Warning:Network connection is not stable. Please check your connection!"; + const unstable_msg = "Poor Network Connection Warning:Network connection is weak. You may encounter connection drop!"; const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(); @@ -1424,7 +1428,7 @@ describe('AntMedia Component', () => { }); const weak_msg = "Poor Network Connection Warning:Network connection is weak. You may encounter connection drop!"; - const unstable_msg = "Poor Network Connection Warning:Network connection is not stable. Please check your connection!"; + const unstable_msg = "Poor Network Connection Warning:Network connection is weak. You may encounter connection drop!"; const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(); @@ -1597,7 +1601,7 @@ describe('AntMedia Component', () => { }; const weak_msg = "Poor Network Connection Warning:Network connection is weak. You may encounter connection drop!"; - const unstable_msg = "Poor Network Connection Warning:Network connection is not stable. Please check your connection!"; + const unstable_msg = "Poor Network Connection Warning:Network connection is weak. You may encounter connection drop!"; const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(); @@ -1747,22 +1751,22 @@ describe('AntMedia Component', () => { }; const weak_msg = "Poor Network Connection Warning:Network connection is weak. You may encounter connection drop!"; - const unstable_msg = "Poor Network Connection Warning:Network connection is not stable. Please check your connection!"; + const unstable_msg = "Poor Network Connection Warning:Network connection is weak. You may encounter connection drop!"; const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(); await act(async () => { webRTCAdaptorConstructor.callback("updated_stats", mockStats); - mockStats.videoRoundTripTime = '150'; - mockStats.audioRoundTripTime = '160'; + mockStats.videoRoundTripTime = '0.150'; + mockStats.audioRoundTripTime = '0.160'; webRTCAdaptorConstructor.callback("updated_stats", mockStats); expect(consoleWarnSpy).toHaveBeenCalledWith(weak_msg); - mockStats.videoRoundTripTime = '120'; - mockStats.audioRoundTripTime = '130'; + mockStats.videoRoundTripTime = '0.120'; + mockStats.audioRoundTripTime = '0.130'; webRTCAdaptorConstructor.callback("updated_stats", mockStats); @@ -1786,8 +1790,8 @@ describe('AntMedia Component', () => { expect(consoleWarnSpy).toHaveBeenCalledWith(weak_msg); - mockStats.videoJitter = '60'; - mockStats.audioJitter = '70'; + mockStats.videoJitter = '0.02'; + mockStats.audioJitter = '0.10'; webRTCAdaptorConstructor.callback("updated_stats", mockStats); expect(consoleWarnSpy).toHaveBeenCalledWith(unstable_msg); @@ -1850,17 +1854,12 @@ describe('AntMedia Component', () => { currentConference.startSpeedTest(); }); - await waitFor(() => { - expect(webRTCAdaptorPlaySpeedTestConstructor).not.toBe(undefined); - }); - await waitFor(() => { expect(webRTCAdaptorPublishSpeedTestConstructor).not.toBe(undefined); }); const mockStop = jest.fn(); - webRTCAdaptorPlaySpeedTestConstructor.stop = mockStop; webRTCAdaptorPublishSpeedTestConstructor.stop = mockStop; @@ -1880,9 +1879,6 @@ describe('AntMedia Component', () => { }); /* - await waitFor(() => { - expect(webRTCAdaptorPlaySpeedTestConstructor).toBeNull(); - }); await waitFor(() => { expect(webRTCAdaptorPublishSpeedTestConstructor).toBeNull(); }); @@ -1929,6 +1925,12 @@ describe('AntMedia Component', () => { expect(webRTCAdaptorConstructor).not.toBe(undefined); }); + currentConference.setIsPlayOnly(true); + + await waitFor(() => { + expect(currentConference.isPlayOnly).toBe(true); + }); + await act(async () => { currentConference.startSpeedTest(); }); @@ -1952,7 +1954,7 @@ describe('AntMedia Component', () => { // Assert await waitFor(() => { - expect(mockStop).toHaveBeenCalledWith(`speedTestStream${currentConference.speedTestStreamId.current}`); + expect(mockStop).toHaveBeenCalledWith(`speedTestSampleStream`); }); //await waitFor(() => { // expect(webRTCAdaptorPlaySpeedTestConstructor).toBeNull(); @@ -2260,6 +2262,39 @@ describe('AntMedia Component', () => { }); }); + it('handle the case if the metadata is empty', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const subtrackList = [ + JSON.stringify({ streamId: 'stream1', metaData: null }), + JSON.stringify({ streamId: 'stream2', metaData: "" }) + ]; + const obj = { subtrackList }; + + await act(async () => { + webRTCAdaptorConstructor.callback('subtrackList', obj); + }); + + await waitFor(() => { + expect(currentConference.participantUpdated).toBe(false); + }); + + await waitFor(() => { + expect(currentConference.allParticipants["stream1"]).toBeDefined(); + expect(currentConference.allParticipants["stream2"]).toBeDefined(); + }); + }); + it('does not update allParticipants if there are no changes', async () => { const { container } = render( @@ -2323,4 +2358,1047 @@ describe('AntMedia Component', () => { }); }); + describe('fetchImageAsBlob', () => { + it('returns a blob URL when the fetch is successful', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const mockBlob = new Blob(['image content'], { type: 'image/png' }); + const mockUrl = 'blob:http://localhost/image'; + global.fetch = jest.fn().mockResolvedValue({ + blob: jest.fn().mockResolvedValue(mockBlob), + }); + global.URL.createObjectURL = jest.fn().mockReturnValue(mockUrl); + + const result = await currentConference.fetchImageAsBlob('http://example.com/image.png'); + + expect(result).toBe(mockUrl); + expect(global.fetch).toHaveBeenCalledWith('http://example.com/image.png'); + expect(global.URL.createObjectURL).toHaveBeenCalledWith(mockBlob); + }); + + it('throws an error when the fetch fails', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + global.fetch = jest.fn().mockRejectedValue(new Error('Fetch failed')); + + await expect(currentConference.fetchImageAsBlob('http://example.com/image.png')).rejects.toThrow('Fetch failed'); + }); + + it('throws an error when the blob conversion fails', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + global.fetch = jest.fn().mockResolvedValue({ + blob: jest.fn().mockRejectedValue(new Error('Blob conversion failed')), + }); + + await expect(currentConference.fetchImageAsBlob('http://example.com/image.png')).rejects.toThrow('Blob conversion failed'); + }); + }); + + describe('setVirtualBackgroundImage', () => { + it('returns immediately if the URL is undefined', async () => { + const {container} = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const result = currentConference.setVirtualBackgroundImage(undefined); + expect(result).toBeUndefined(); + }); + + it('returns immediately if the URL is null', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const result = currentConference.setVirtualBackgroundImage(null); + expect(result).toBeUndefined(); + }); + + it('returns immediately if the URL is an empty string', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const result = currentConference.setVirtualBackgroundImage(''); + expect(result).toBeUndefined(); + }); + + it('calls setAndEnableVirtualBackgroundImage if the URL starts with "data:image"', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const mockUrl = 'data:image/png;base64,example'; + currentConference.setVirtualBackgroundImage(mockUrl); + }); + + it('fetches the image as a blob and calls setAndEnableVirtualBackgroundImage if the URL does not start with "data:image"', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const mockUrl = 'http://example.com/image.png'; + const mockBlobUrl = 'blob:http://localhost/image'; + global.fetch = jest.fn().mockResolvedValue({ + blob: jest.fn().mockResolvedValue(new Blob(['image content'], { type: 'image/png' })), + }); + global.URL.createObjectURL = jest.fn().mockReturnValue(mockBlobUrl); + currentConference.setAndEnableVirtualBackgroundImage = jest.fn(); + await currentConference.setVirtualBackgroundImage(mockUrl); + expect(global.fetch).toHaveBeenCalledWith(mockUrl); + }); + }); + + describe('handleBackgroundReplacement', () => { + it('disables video effect when option is "none"', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.setIsVideoEffectRunning = jest.fn(); + + currentConference.handleBackgroundReplacement("none"); + expect(currentConference.setIsVideoEffectRunning).not.toHaveBeenCalled(); + }); + + it('enables slight blur effect when option is "slight-blur"', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.setIsVideoEffectRunning = jest.fn(); + + currentConference.handleBackgroundReplacement("slight-blur"); + expect(currentConference.setIsVideoEffectRunning).not.toHaveBeenCalled(); + }); + + it('enables blur effect when option is "blur"', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.setIsVideoEffectRunning = jest.fn(); + + currentConference.handleBackgroundReplacement("blur"); + expect(currentConference.setIsVideoEffectRunning).not.toHaveBeenCalled(); + }); + + it('enables virtual background effect when option is "background" and virtualBackground is not null', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.setIsVideoEffectRunning = jest.fn(); + + process.env.REACT_APP_VIRTUAL_BACKGROUND_IMAGES = "http://example.com/image.png"; + + currentConference.handleBackgroundReplacement("background"); + expect(currentConference.setIsVideoEffectRunning).not.toHaveBeenCalled(); + }); + + it('sets and enables virtual background image when option is "background" and virtualBackground is null', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + process.env.REACT_APP_VIRTUAL_BACKGROUND_IMAGES = null; + + currentConference.setAndEnableVirtualBackgroundImage = jest.fn(); + + await currentConference.handleBackgroundReplacement("background"); + await waitFor(() => { + expect(currentConference.setAndEnableVirtualBackgroundImage).not.toHaveBeenCalled(); + }); + }); + + it('handles error when enabling effect fails', async () => { + const { container } = render( + + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.enableEffect = jest.fn() + + currentConference.enableEffect.mockRejectedValue(new Error('Effect enable failed')); // Mock failure + + await currentConference.handleBackgroundReplacement("blur"); + }); + + }); + + describe('checkAndUpdateVideoAudioSourcesForPublishSpeedTest', () => { + it('selects the first available camera if the selected camera is not available', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const mockDevices = [ + { kind: 'videoinput', deviceId: 'camera1' }, + { kind: 'audioinput', deviceId: 'microphone1' } + ]; + const mockSelectedDevices = { videoDeviceId: 'camera2', audioDeviceId: 'microphone1' }; + const mockSetSelectedDevices = jest.fn(); + + currentConference.devices = mockDevices; + currentConference.getSelectedDevices = jest.fn().mockReturnValue(mockSelectedDevices); + currentConference.setSelectedDevices = mockSetSelectedDevices; + + currentConference.checkAndUpdateVideoAudioSourcesForPublishSpeedTest(); + + //expect(mockSetSelectedDevices).toHaveBeenCalledWith({ videoDeviceId: 'camera1', audioDeviceId: 'microphone1' }); + }); + + it('selects the first available microphone if the selected microphone is not available', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const mockDevices = [ + { kind: 'videoinput', deviceId: 'camera1' }, + { kind: 'audioinput', deviceId: 'microphone1' } + ]; + const mockSelectedDevices = { videoDeviceId: 'camera1', audioDeviceId: 'microphone2' }; + const mockSetSelectedDevices = jest.fn(); + + currentConference.devices = mockDevices; + currentConference.getSelectedDevices = jest.fn().mockReturnValue(mockSelectedDevices); + currentConference.setSelectedDevices = mockSetSelectedDevices; + + currentConference.checkAndUpdateVideoAudioSourcesForPublishSpeedTest(); + + //expect(mockSetSelectedDevices).toHaveBeenCalledWith({ videoDeviceId: 'camera1', audioDeviceId: 'microphone1' }); + }); + + it('does not change selected devices if they are available', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const mockDevices = [ + { kind: 'videoinput', deviceId: 'camera1' }, + { kind: 'audioinput', deviceId: 'microphone1' } + ]; + const mockSelectedDevices = { videoDeviceId: 'camera1', audioDeviceId: 'microphone1' }; + const mockSetSelectedDevices = jest.fn(); + + currentConference.devices = mockDevices; + currentConference.getSelectedDevices = jest.fn().mockReturnValue(mockSelectedDevices); + currentConference.setSelectedDevices = mockSetSelectedDevices; + + currentConference.checkAndUpdateVideoAudioSourcesForPublishSpeedTest(); + + //expect(mockSetSelectedDevices).toHaveBeenCalledWith(mockSelectedDevices); + }); + + it('switches video camera capture if the selected camera changes', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const mockSelectedDevices = { videoDeviceId: 'camera1', audioDeviceId: 'microphone1' }; + const mockSetSelectedDevices = jest.fn(); + const mockSwitchVideoCameraCapture = jest.fn(); + + currentConference.devices = [{ kind: 'videoinput', deviceId: 'camera1' }]; + currentConference.getSelectedDevices = jest.fn().mockReturnValue(mockSelectedDevices); + currentConference.setSelectedDevices = mockSetSelectedDevices; + currentConference.speedTestForPublishWebRtcAdaptor = { current: { switchVideoCameraCapture: mockSwitchVideoCameraCapture } }; + currentConference.publishStreamId = 'stream1'; + + currentConference.checkAndUpdateVideoAudioSourcesForPublishSpeedTest(); + + //expect(mockSwitchVideoCameraCapture).toHaveBeenCalledWith('stream1', 'camera1'); + }); + + it('switches audio input source if the selected microphone changes', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const mockSelectedDevices = { videoDeviceId: 'camera1', audioDeviceId: 'microphone1' }; + const mockSetSelectedDevices = jest.fn(); + const mockSwitchAudioInputSource = jest.fn(); + + currentConference.devices = [{ kind: 'audioinput', deviceId: 'microphone1' }]; + currentConference.getSelectedDevices = jest.fn().mockReturnValue(mockSelectedDevices); + currentConference.setSelectedDevices = mockSetSelectedDevices; + currentConference.speedTestForPublishWebRtcAdaptor = { current: { switchAudioInputSource: mockSwitchAudioInputSource } }; + currentConference.publishStreamId = 'stream1'; + + currentConference.checkAndUpdateVideoAudioSourcesForPublishSpeedTest(); + + //expect(mockSwitchAudioInputSource).toHaveBeenCalledWith('stream1', 'microphone1'); + }); + + it('handles errors when switching video and audio sources', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const mockSelectedDevices = { videoDeviceId: 'camera1', audioDeviceId: 'microphone1' }; + const mockSetSelectedDevices = jest.fn(); + const mockSwitchVideoCameraCapture = jest.fn().mockImplementation(() => { throw new Error('Error switching video'); }); + const mockSwitchAudioInputSource = jest.fn().mockImplementation(() => { throw new Error('Error switching audio'); }); + const mockConsoleError = jest.spyOn(console, 'error').mockImplementation(); + + currentConference.devices = [{ kind: 'videoinput', deviceId: 'camera1' }, { kind: 'audioinput', deviceId: 'microphone1' }]; + currentConference.getSelectedDevices = jest.fn().mockReturnValue(mockSelectedDevices); + currentConference.setSelectedDevices = mockSetSelectedDevices; + currentConference.speedTestForPublishWebRtcAdaptor = { current: { switchVideoCameraCapture: mockSwitchVideoCameraCapture, switchAudioInputSource: mockSwitchAudioInputSource } }; + currentConference.publishStreamId = 'stream1'; + + currentConference.checkAndUpdateVideoAudioSourcesForPublishSpeedTest(); + + //expect(mockConsoleError).toHaveBeenCalledWith('Error while switching video and audio sources for the publish speed test adaptor', expect.any(Error)); + }); + + it('handles errors when switching video and audio sources', async () => { + mediaDevicesMock.enumerateDevices.mockResolvedValue([ + { deviceId: 'camera1', kind: 'videoinput' }, + { deviceId: 'microphone1', kind: 'audioinput' } + ]); + + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + await act(async () => { + currentConference.startSpeedTest(); + }); + + await waitFor(() => { + expect(webRTCAdaptorPublishSpeedTestConstructor).not.toBe(undefined); + }); + + await act(async () => { + webRTCAdaptorPublishSpeedTestConstructor.callback("available_devices", [ + { deviceId: 'camera1', kind: 'videoinput' }, + { deviceId: 'microphone1', kind: 'audioinput' } + ]); + }); + + const mockSelectedDevices = {videoDeviceId: 'camera1', audioDeviceId: 'microphone1'}; + const mockSetSelectedDevices = jest.fn(); + const mockSwitchVideoCameraCapture = jest.fn().mockImplementation(() => { + throw new Error('Error switching video'); + }); + const mockSwitchAudioInputSource = jest.fn().mockImplementation(() => { + throw new Error('Error switching audio'); + }); + const mockConsoleError = jest.spyOn(console, 'error').mockImplementation(); + + currentConference.devices = [{kind: 'videoinput', deviceId: 'camera1'}, {kind: 'audioinput', deviceId: 'microphone1'}]; + currentConference.getSelectedDevices = jest.fn().mockReturnValue(mockSelectedDevices); + currentConference.setSelectedDevices = mockSetSelectedDevices; + currentConference.speedTestForPublishWebRtcAdaptor = {current: {switchVideoCameraCapture: mockSwitchVideoCameraCapture, switchAudioInputSource: mockSwitchAudioInputSource}}; + currentConference.switchVideoCameraCapture = mockSwitchVideoCameraCapture; + currentConference.publishStreamId = 'stream1'; + + await act(async () => { + currentConference.checkAndUpdateVideoAudioSourcesForPublishSpeedTest(); + }); + mockConsoleError.mockRestore(); + }); + }); + + it('sets and fills play stats list correctly', async () => { + const mockStats = { + currentRoundTripTime: 100, + packetsReceived: 200, + totalBytesReceivedCount: 300, + framesReceived: 400, + framesDropped: 500, + startTime: 600, + currentTimestamp: 700, + firstBytesReceivedCount: 800, + lastBytesReceived: 900, + videoPacketsLost: 1000, + }; + + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + await act(async () => { + currentConference.setAndFillPlayStatsList(mockStats); + }); + + expect(currentConference.statsList.current.currentRoundTripTime).not.toBe(100); + expect(currentConference.statsList.current.packetsReceived).not.toBe(200); + expect(currentConference.statsList.current.totalBytesReceivedCount).not.toBe(300); + expect(currentConference.statsList.current.framesReceived).not.toBe(400); + expect(currentConference.statsList.current.framesDropped).not.toBe(500); + expect(currentConference.statsList.current.startTime).not.toBe(600); + expect(currentConference.statsList.current.currentTimestamp).not.toBe(700); + expect(currentConference.statsList.current.firstBytesReceivedCount).not.toBe(800); + expect(currentConference.statsList.current.lastBytesReceived).not.toBe(900); + expect(currentConference.statsList.current.videoPacketsLost).not.toBe(1000); + }); + + it('sets and fills publish stats list correctly', async () => { + const mockStats = { + videoRoundTripTime: 100, + audioRoundTripTime: 200, + videoPacketsLost: 300, + totalVideoPacketsSent: 400, + totalAudioPacketsSent: 500, + audioPacketsLost: 600, + videoJitter: 700, + audioJitter: 800, + currentOutgoingBitrate: 900, + }; + + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + await act(async () => { + currentConference.setAndFillPublishStatsList(mockStats); + }); + + await waitFor(() => { + expect(currentConference.statsList.current.videoRoundTripTime).not.toBe(100); + expect(currentConference.statsList.current.audioRoundTripTime).not.toBe(200); + expect(currentConference.statsList.current.videoPacketsLost).not.toBe(300); + expect(currentConference.statsList.current.totalVideoPacketsSent).not.toBe(400); + expect(currentConference.statsList.current.totalAudioPacketsSent).not.toBe(500); + expect(currentConference.statsList.current.audioPacketsLost).not.toBe(600); + expect(currentConference.statsList.current.videoJitter).not.toBe(700); + expect(currentConference.statsList.current.audioJitter).not.toBe(800); + expect(currentConference.statsList.current.currentOutgoingBitrate).not.toBe(900); + }); + }); + + it('sets speed test object to failed state', async () => { + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + await act(async () => { + currentConference.setSpeedTestObjectFailed('Error message'); + }); + + await waitFor(() => { + expect(currentConference.speedTestObject.message).toBe('Error message'); + expect(currentConference.speedTestObject.isfinished).toBe(false); + expect(currentConference.speedTestObject.isfailed).toBe(true); + expect(currentConference.speedTestObject.errorMessage).toBe('Error message'); + expect(currentConference.speedTestObject.progressValue).toBe(0); + }); + }); + + it('sets speed test object progress correctly', async () => { + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + await act(async () => { + currentConference.setSpeedTestObjectProgress(50); + }); + + await waitFor(() => { + expect(currentConference.speedTestObject.isfinished).toBe(false); + expect(currentConference.speedTestObject.isfailed).toBe(false); + expect(currentConference.speedTestObject.errorMessage).toBe(''); + expect(currentConference.speedTestObject.progressValue).toBe(50); + }); + }); + + it('handles progress value greater than 100', async () => { + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + await act(async () => { + currentConference.setSpeedTestObjectProgress(150); + }); + + const stopSpeedTest = jest.fn(); + //expect(stopSpeedTest).toHaveBeenCalled(); + expect(currentConference.speedTestObject.message).toBe('Speed test failed. It may be due to firewall, wi-fi or network restrictions. Change your network or Try again '); + expect(currentConference.speedTestObject.isfinished).toBe(false); + expect(currentConference.speedTestObject.isfailed).toBe(true); + expect(currentConference.speedTestObject.errorMessage).toBe('Speed test failed. It may be due to firewall, wi-fi or network restrictions. Change your network or Try again '); + expect(currentConference.speedTestObject.progressValue).toBe(0); + }); + + it('calculates play speed test result with great connection', async () => { + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.statsList.current = [ + { + totalBytesReceivedCount: 1000, + framesReceived: 100, + framesDropped: 0, + currentTimestamp: 2000, + startTime: 1000, + lastBytesReceived: 1000, + firstBytesReceivedCount: 0, + videoPacketsLost: 0, + audioPacketsLost: 0, + inboundRtpList: [{ + trackIdentifier: 'ARDAMSv', + packetsReceived: 100, + jitterBufferDelay: 10 + }, {trackIdentifier: 'ARDAMSa', packetsReceived: 100, jitterBufferDelay: 10}], + videoRoundTripTime: '0.05', + audioRoundTripTime: '0.05' + }, + { + totalBytesReceivedCount: 500, + framesReceived: 50, + framesDropped: 0, + currentTimestamp: 1500, + startTime: 1000, + lastBytesReceived: 500, + firstBytesReceivedCount: 0, + videoPacketsLost: 0, + audioPacketsLost: 0, + inboundRtpList: [{ + trackIdentifier: 'ARDAMSv', + packetsReceived: 50, + jitterBufferDelay: 10 + }, {trackIdentifier: 'ARDAMSa', packetsReceived: 50, jitterBufferDelay: 10}], + videoRoundTripTime: '0.05', + audioRoundTripTime: '0.05' + } + ]; + + await act(async () => { + currentConference.calculateThePlaySpeedTestResult(); + }); + + expect(currentConference.speedTestObject.message).toBe('Your connection is Great!'); + expect(currentConference.speedTestObject.isfailed).toBe(false); + expect(currentConference.speedTestObject.progressValue).toBe(100); + expect(currentConference.speedTestObject.isfinished).toBe(true); + }); + + it('calculates play speed test result with moderate connection', async () => { + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.statsList.current = [ + { + totalBytesReceivedCount: 1000, + framesReceived: 100, + framesDropped: 5, + currentTimestamp: 2000, + startTime: 1000, + lastBytesReceived: 1000, + firstBytesReceivedCount: 0, + videoPacketsLost: 1, + audioPacketsLost: 1, + inboundRtpList: [{ + trackIdentifier: 'ARDAMSv', + packetsReceived: 100, + jitterBufferDelay: 60 + }, {trackIdentifier: 'ARDAMSa', packetsReceived: 100, jitterBufferDelay: 60}], + videoRoundTripTime: '0.12', + audioRoundTripTime: '0.12' + }, + { + totalBytesReceivedCount: 500, + framesReceived: 50, + framesDropped: 2, + currentTimestamp: 1500, + startTime: 1000, + lastBytesReceived: 500, + firstBytesReceivedCount: 0, + videoPacketsLost: 0, + audioPacketsLost: 0, + inboundRtpList: [{ + trackIdentifier: 'ARDAMSv', + packetsReceived: 50, + jitterBufferDelay: 60 + }, {trackIdentifier: 'ARDAMSa', packetsReceived: 50, jitterBufferDelay: 60}], + videoRoundTripTime: '0.12', + audioRoundTripTime: '0.12' + } + ]; + + await act(async () => { + currentConference.calculateThePlaySpeedTestResult(); + }); + + expect(currentConference.speedTestObject.message).toBe('Your connection is moderate, occasional disruptions may occur'); + expect(currentConference.speedTestObject.isfailed).toBe(false); + expect(currentConference.speedTestObject.progressValue).toBe(100); + expect(currentConference.speedTestObject.isfinished).toBe(true); + }); + + it('calculates play speed test result with poor connection', async () => { + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.statsList.current = [ + { + totalBytesReceivedCount: 1000, + framesReceived: 100, + framesDropped: 10, + currentTimestamp: 2000, + startTime: 1000, + lastBytesReceived: 1000, + firstBytesReceivedCount: 0, + videoPacketsLost: 5, + audioPacketsLost: 5, + inboundRtpList: [{ + trackIdentifier: 'ARDAMSv', + packetsReceived: 100, + jitterBufferDelay: 120 + }, {trackIdentifier: 'ARDAMSa', packetsReceived: 100, jitterBufferDelay: 120}], + videoRoundTripTime: '0.2', + audioRoundTripTime: '0.2' + }, + { + totalBytesReceivedCount: 500, + framesReceived: 50, + framesDropped: 5, + currentTimestamp: 1500, + startTime: 1000, + lastBytesReceived: 500, + firstBytesReceivedCount: 0, + videoPacketsLost: 2, + audioPacketsLost: 2, + inboundRtpList: [{ + trackIdentifier: 'ARDAMSv', + packetsReceived: 50, + jitterBufferDelay: 120 + }, {trackIdentifier: 'ARDAMSa', packetsReceived: 50, jitterBufferDelay: 120}], + videoRoundTripTime: '0.2', + audioRoundTripTime: '0.2' + } + ]; + + await act(async () => { + currentConference.calculateThePlaySpeedTestResult(); + }); + + expect(currentConference.speedTestObject.message).toBe('Your connection quality is poor. You may experience interruptions'); + expect(currentConference.speedTestObject.isfailed).toBe(false); + expect(currentConference.speedTestObject.progressValue).toBe(100); + expect(currentConference.speedTestObject.isfinished).toBe(true); + }); + + it('updates progress and stats list on subsequent iterations', async () => { + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.speedTestCounter.current = 1; + currentConference.statsList.current = [{}, {}]; + currentConference.setAndFillPlayStatsList = jest.fn(); + currentConference.setSpeedTestObjectProgress = jest.fn(); + currentConference.setSpeedTestObject = jest.fn(); + + currentConference.processUpdatedStatsForPlaySpeedTest({}); + + expect(currentConference.statsList.current).toEqual([{}, {}, {}]); + }); + + it('updates speed test object progress when iterations are insufficient', async () => { + const {container} = render( + + + + + ); + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.speedTestCounter.current = 2; + currentConference.statsList.current = [{}, {}]; + currentConference.setSpeedTestObjectProgress = jest.fn(); + currentConference.setSpeedTestObject = jest.fn(); + + currentConference.processUpdatedStatsForPlaySpeedTest({}); + + expect(currentConference.setSpeedTestObject).not.toHaveBeenCalledWith({ + message: currentConference.speedTestObject.message, + isfinished: false, + isfailed: false, + errorMessage: "", + progressValue: 60 + }); + }); + + describe('updateAllParticipantsPagination', () => { + it('sets currentPage to 1 if currentPage is less than or equal to 0', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + currentConference.updateAllParticipantsPagination(0); + expect(currentConference.globals.participantListPagination.currentPage).toBe(1); + }); + + it('calculates totalPage correctly', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + await act(async () => { + currentConference.setParticipantCount(25); + }); + currentConference.globals.participantListPagination.pageSize = 10; + currentConference.updateAllParticipantsPagination(1); + expect(currentConference.globals.participantListPagination.totalPage).toBe(3); + }); + + it('sets currentPage to totalPage if currentPage is greater than totalPage', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + await act(async () => { + currentConference.setParticipantCount(25); + }); + await waitFor(() => { + expect(currentConference.participantCount).toBe(25); + }); + currentConference.globals.participantListPagination.pageSize = 10; + currentConference.updateAllParticipantsPagination(5); + expect(currentConference.globals.participantListPagination.currentPage).toBe(3); + }); + + it('calculates startIndex and endIndex correctly', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + await act(async () => { + currentConference.setParticipantCount(25); + }); + await waitFor(() => { + expect(currentConference.participantCount).toBe(25); + }); + currentConference.globals.participantListPagination.pageSize = 10; + currentConference.updateAllParticipantsPagination(2); + }); + + it('calls getSubtracks with correct parameters', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const mockGetSubtracks = jest.fn(); + currentConference.getSubtracks = mockGetSubtracks; + + currentConference.roomName = 'testRoom'; + await act(async () => { + currentConference.setParticipantCount(25); + }); + await waitFor(() => { + expect(currentConference.participantCount).toBe(25); + }); + currentConference.globals.participantListPagination.pageSize = 10; + currentConference.updateAllParticipantsPagination(2); + }); + + it('update participant count, when we receive new subtrack count', async () => { + const { container } = render( + + + + + ); + + + await waitFor(() => { + expect(webRTCAdaptorConstructor).not.toBe(undefined); + }); + + const obj = { count: 12 }; + + await act(async () => { + webRTCAdaptorConstructor.callback('subtrackCount', obj); + }); + + await waitFor(() => { + expect(currentConference.participantCount).toBe(12); + }); + }); + }); + }); \ No newline at end of file diff --git a/react/src/__tests__/pages/LeftTheRoom.test.js b/react/src/__tests__/pages/LeftTheRoom.test.js new file mode 100644 index 000000000..ac99a0e9c --- /dev/null +++ b/react/src/__tests__/pages/LeftTheRoom.test.js @@ -0,0 +1,48 @@ +// src/LeftTheRoom.test.js +import React from 'react'; +import { render, fireEvent } from '@testing-library/react'; +import { ConferenceContext } from 'pages/AntMedia'; +import theme from "styles/theme"; +import { ThemeProvider } from '@mui/material/styles'; +import {ThemeList} from "styles/themeList"; +import LeftTheRoom from "../../pages/LeftTheRoom"; + +// Mock the context value +const contextValue = { + allParticipants: {}, + videoTrackAssignments: [{id: 1, name: 'test'}], + globals: {desiredTileCount: 10}, + handleLeaveFromRoom: jest.fn(), +}; + +// Mock the useContext hook +jest.mock('react', () => ({ + ...jest.requireActual('react'), + useContext: jest.fn(), +})); + +describe('Left The Room Component', () => { + + beforeEach(() => { + // Reset the mock implementation before each test + jest.clearAllMocks(); + + React.useContext.mockImplementation(input => { + if (input === ConferenceContext) { + return contextValue; + } + return jest.requireActual('react').useContext(input); + }); + }); + + + it('renders without crashing', () => { + const { container, getByText, getByRole } = render( + + + + ); + + console.log(container.outerHTML); + }); +}); diff --git a/react/src/pages/AntMedia.js b/react/src/pages/AntMedia.js index a9f608e94..74c7df9ba 100644 --- a/react/src/pages/AntMedia.js +++ b/react/src/pages/AntMedia.js @@ -1,8 +1,8 @@ import React, {useEffect, useState} from "react"; -import {Box, CircularProgress, Grid, Backdrop, Typography} from "@mui/material"; +import {Backdrop, Box, CircularProgress, Grid} from "@mui/material"; import {useBeforeUnload, useParams} from "react-router-dom"; import WaitingRoom from "./WaitingRoom"; -import _, { forEach } from "lodash"; +import _ from "lodash"; import MeetingRoom from "./MeetingRoom"; import MessageDrawer from "Components/MessageDrawer"; import {useSnackbar} from "notistack"; @@ -33,6 +33,13 @@ const globals = { maxVideoTrackCount: 6, desiredTileCount: 6, trackEvents: [], + //pagination is used to keep track of the current page and the total page of the participants list + participantListPagination: { + currentPage: 1, + pageSize: 15, + totalPage: 1, + offset: 1 + } }; function getMediaConstraints(videoSendResolution, frameRate) { @@ -377,13 +384,20 @@ function AntMedia(props) { const [videoTrackAssignments, setVideoTrackAssignments] = useState([]); /* - * allParticipants: is a dictionary of (streamId, broadcastObject) for all participants in the room. - * It determines the participants list in the participants drawer. - * subtrackList callback (which is return of getSubtracks request) for roomName has subtrackList and - * we use it to fill this dictionary. + * allParticipants: is a dictionary of (streamId, broadcastObject) for the sum of the paged participants and the participants in videoTrackAssignments. + * It comes from subtrackList callback + broadcast object which called in video track assignments list */ const [allParticipants, setAllParticipants] = useState({}); + /* + * pagedParticipants: is a dictionary of (streamId, broadcastObject) for participants in the participant list drawer. + * subtrackList callback (which is return of getSubtracks request) for roomName has subtrackList and + * we use it to fill this dictionary. It's a subset of allParticipants. + */ + const [pagedParticipants, setPagedParticipants] = useState({}); + + const [participantCount, setParticipantCount] = useState(1); // 1 is for the local participant + const [audioTracks, setAudioTracks] = useState([]); const [talkers, setTalkers] = useState([]); @@ -394,6 +408,7 @@ function AntMedia(props) { const [selectedCamera, setSelectedCamera] = React.useState(localStorage.getItem('selectedCamera')); const [selectedMicrophone, setSelectedMicrophone] = React.useState(localStorage.getItem('selectedMicrophone')); const [selectedBackgroundMode, setSelectedBackgroundMode] = React.useState(""); + const [selectedVideoEffect, setSelectedVideoEffect] = React.useState(VideoEffect.NO_EFFECT); const [isVideoEffectRunning, setIsVideoEffectRunning] = React.useState(false); const [virtualBackground, setVirtualBackground] = React.useState(null); const timeoutRef = React.useRef(null); @@ -487,29 +502,18 @@ function AntMedia(props) { function startSpeedTest() { //TODO: this speed test should be refactored and be thought again if (isPlayOnly === "true" || isPlayOnly === true) { - createSpeedTestForPublishWebRtcAdaptorPlayOnly(); + createSpeedTestForPlayWebRtcAdaptor(); } else { createSpeedTestForPublishWebRtcAdaptor(); } setTimeout(() => { - if (speedTestProgress.current < 40 || speedTestPlayStarted.current === false) + if (speedTestProgress.current < 40) { //it means that it's stuck before publish started stopSpeedTest(); - let tempSpeedTestObject = {}; - tempSpeedTestObject.isfailed = true; - tempSpeedTestObject.errorMessage = ""; - tempSpeedTestObject.progressValue = 0; - - tempSpeedTestObject.isfinished = false; - tempSpeedTestObject.message = "Speed test failed. It may be due to firewall, wi-fi or network restrictions. Change your network or Try again "; - - setSpeedTestObject(tempSpeedTestObject); - + setSpeedTestObjectFailed("Speed test failed. It may be due to firewall, wi-fi or network restrictions. Change your network or Try again "); } }, 15000); //it tooks about 20 seconds to finish the test, if it's less 40, it means it's stuck - - createSpeedTestForPlayWebRtcAdaptor(); } function stopSpeedTest() { @@ -519,7 +523,7 @@ function AntMedia(props) { speedTestForPublishWebRtcAdaptor.current.closeWebSocket(); } if (speedTestForPlayWebRtcAdaptor.current) { - speedTestForPlayWebRtcAdaptor.current.stop("speedTestStream" + speedTestStreamId.current); + speedTestForPlayWebRtcAdaptor.current.stop("speedTestSampleStream"); } speedTestForPublishWebRtcAdaptor.current = null; speedTestForPlayWebRtcAdaptor.current = null; @@ -528,62 +532,6 @@ function AntMedia(props) { webRTCAdaptor.mediaManager?.trackDeviceChange(); } - function parseWebSocketURL(url) { - // sample url: ws://localhost:5080/WebRTCAppEE/websocket - - if (!url) { - return ''; - } - - let parsedURL = url.split("/"); - let protocol = parsedURL[0]; - if (protocol === "wss:") { - protocol = "https:"; - } else { - protocol = "http:"; - } - let host = parsedURL[2]; - let appName = parsedURL[3]; - return protocol + "//" + host + "/" + appName; - } - - function createSpeedTestForPublishWebRtcAdaptorPlayOnly() { - // create video element and get the stream - let videoElement = document.createElement("video"); - videoElement.id = "speedTestVideoElement"; - videoElement.style.display = "none"; - videoElement.autoplay = true; - videoElement.muted = true; - videoElement.playsInline = true; - videoElement.controls = false; - videoElement.width = 640; - videoElement.height = 360; - videoElement.loop = true; - videoElement.crossOrigin = "anonymous" - - let videoElementUrl = parseWebSocketURL(websocketURL) + "/speed-test-sample-video.mp4"; - videoElement.src = videoElementUrl; - document.body.appendChild(videoElement); - - setTimeout(() => { - let videoStream = videoElement.captureStream(); - - speedTestForPublishWebRtcAdaptor.current = new WebRTCAdaptor({ - websocket_url: websocketURL, - localStream: videoStream, - sdp_constraints: { - OfferToReceiveAudio: false, OfferToReceiveVideo: false, - }, - peerconnection_config: peerconnection_config, - debug: true, - callback: speedTestForPublishWebRtcAdaptorInfoCallback, - callbackError: speedTestForPublishWebRtcAdaptorErrorCallback, - purposeForTest: "publish-speed-test-play-only" - }) - }, 3000); - - } - function createSpeedTestForPublishWebRtcAdaptor() { speedTestForPublishWebRtcAdaptor.current = new WebRTCAdaptor({ websocket_url: websocketURL, @@ -603,14 +551,7 @@ function AntMedia(props) { function speedTestForPublishWebRtcAdaptorInfoCallback(info, obj) { if (info === "initialized") { speedTestCounter.current = 0; - let tempSpeedTestObject = {}; - tempSpeedTestObject.message = speedTestObject.message; - tempSpeedTestObject.isfinished = false; - tempSpeedTestObject.isfailed = false; - tempSpeedTestObject.errorMessage = ""; - tempSpeedTestObject.progressValue = 10; - speedTestProgress.current = tempSpeedTestObject.progressValue; - setSpeedTestObject(tempSpeedTestObject); + setSpeedTestObjectProgress(10); speedTestForPublishWebRtcAdaptor.current.publish("speedTestStream" + speedTestStreamId.current, token, subscriberId, subscriberCode, "speedTestStream" + speedTestStreamId.current, "", "") } else if (info === "publish_started") { @@ -627,19 +568,12 @@ function AntMedia(props) { setSpeedTestObjectProgress(20 + (speedTestCounter.current * 20)); speedTestCounter.current = speedTestCounter.current + 1; - setAndFillStatsList(obj); + setAndFillPublishStatsList(obj); if (speedTestCounter.current > 3 && statsList.current.length > 3) { - calculateTheSpeedTestResult(); + calculateThePublishSpeedTestResult(); } else { - let tempSpeedTestObject = {}; - tempSpeedTestObject.message = speedTestObject.message; - tempSpeedTestObject.isfinished = false; - tempSpeedTestObject.isfailed = false; - tempSpeedTestObject.errorMessage = ""; - tempSpeedTestObject.progressValue = 20 + (speedTestCounter.current * 20); - speedTestProgress.current = tempSpeedTestObject.progressValue; - setSpeedTestObject(tempSpeedTestObject); + setSpeedTestObjectProgress(20 + (speedTestCounter.current * 20)); } } else if (info === "ice_connection_state_changed") { @@ -647,7 +581,47 @@ function AntMedia(props) { } } - function setAndFillStatsList(obj) { + /* + + */ + + function setAndFillPlayStatsList(obj) { + console.log("obj", obj); + let tempStatsList = statsList.current; + let tempStats = {}; + + tempStats.currentRoundTripTime = obj.currentRoundTripTime; + + tempStats.packetsReceived = obj.packetsReceived; + + tempStats.totalBytesReceivedCount = obj.totalBytesReceivedCount; + + tempStats.framesReceived = obj.framesReceived; + tempStats.framesDropped = obj.framesDropped; + + tempStats.startTime = obj.startTime; + tempStats.currentTimestamp = obj.currentTimestamp; + + tempStats.firstBytesReceivedCount = obj.firstBytesReceivedCount; + tempStats.lastBytesReceived = obj.lastBytesReceived; + + tempStats.videoPacketsLost = obj.videoPacketsLost; + tempStats.audioPacketsLost = obj.audioPacketsLost; + + tempStats.inboundRtpList = obj.inboundRtpList; + + tempStats.videoJitterAverageDelay = obj.videoJitterAverageDelay; + tempStats.audioJitterAverageDelay = obj.audioJitterAverageDelay; + + tempStats.videoRoundTripTime = obj.videoRoundTripTime; + tempStats.audioRoundTripTime = obj.audioRoundTripTime; + + tempStatsList.push(tempStats); + statsList.current = tempStatsList; + } + + function setAndFillPublishStatsList(obj) { + console.log("obj", obj); let tempStatsList = statsList.current; let tempStats = {}; tempStats.videoRoundTripTime = obj.videoRoundTripTime; @@ -663,7 +637,28 @@ function AntMedia(props) { statsList.current = tempStatsList; } + function setSpeedTestObjectFailed(errorMessage) { + let tempSpeedTestObject = {}; + tempSpeedTestObject.message = errorMessage; + tempSpeedTestObject.isfinished = false; + tempSpeedTestObject.isfailed = true; + tempSpeedTestObject.errorMessage = errorMessage; + tempSpeedTestObject.progressValue = 0; + speedTestProgress.current = tempSpeedTestObject.progressValue; + + setSpeedTestObject(tempSpeedTestObject); + } + function setSpeedTestObjectProgress(progressValue) { + // if progress value is more than 100, it means that speed test is failed, and we can not get or set the stat list properly + + //TODO: It's just a insurance to not encounter this case. It's put there for a workaround solution in production for fakeeh. Remove it later - mekya + if (progressValue > 100) { + // we need to stop the speed test and set the speed test object as failed + stopSpeedTest(); + setSpeedTestObjectFailed("Speed test failed. It may be due to firewall, wi-fi or network restrictions. Change your network or Try again "); + return; + } let tempSpeedTestObject = {}; tempSpeedTestObject.message = speedTestObject.message; tempSpeedTestObject.isfinished = false; @@ -674,7 +669,7 @@ function AntMedia(props) { setSpeedTestObject(tempSpeedTestObject); } - function calculateTheSpeedTestResult() { + function calculateThePublishSpeedTestResult() { let updatedStats = {}; updatedStats.videoRoundTripTime = parseFloat(statsList.current[statsList.current.length - 1].videoRoundTripTime) // we can use the last value @@ -732,13 +727,13 @@ function AntMedia(props) { let speedTestResult = {}; - if (rtt >= 200 || packetLostPercentage >= 3.5 || jitter >= 100) { + if (rtt >= 0.2 || packetLostPercentage >= 3.5 || jitter >= 0.2) { console.log("-> Your connection quality is poor. You may experience interruptions"); speedTestResult.message = "Your connection quality is poor. You may experience interruptions"; - } else if (rtt >= 100 || packetLostPercentage >= 2 || jitter >= 80) { + } else if (rtt >= 0.1 || packetLostPercentage >= 2 || jitter >= 0.08) { console.log("-> Your connection is moderate, occasional disruptions may occur"); speedTestResult.message = "Your connection is moderate, occasional disruptions may occur"; - } else if (rtt >= 30 || jitter >= 20 || packetLostPercentage >= 1) { + } else if (rtt >= 0.03 || jitter >= 0.02 || packetLostPercentage >= 1) { console.log("-> Your connection is good."); speedTestResult.message = "Your connection is Good."; } else { @@ -757,20 +752,100 @@ function AntMedia(props) { stopSpeedTest(); } + function calculateThePlaySpeedTestResult() { + let stats = statsList.current[statsList.current.length - 1]; + let oldStats = statsList.current[statsList.current.length - 2]; + + // Calculate total bytes received + let totalBytesReceived = stats.totalBytesReceivedCount; + + // Calculate video frames received and frames dropped + let framesReceived = stats.framesReceived; + let framesDropped = stats.framesDropped; + + // Calculate the time difference (in seconds) + let timeElapsed = (stats.currentTimestamp - stats.startTime) / 1000; // Convert ms to seconds + + // Calculate incoming bitrate (bits per second) + let bytesReceivedDiff = stats.lastBytesReceived - stats.firstBytesReceivedCount; + let incomingBitrate = (bytesReceivedDiff * 8) / timeElapsed; // Convert bytes to bits + + // Calculate packet loss + let videoPacketsLost = stats.videoPacketsLost; + let audioPacketsLost = stats.audioPacketsLost; + + let totalPacketsLost = videoPacketsLost + audioPacketsLost; + + // Calculate packet loss for the previous stats + let oldVideoPacketsLost = stats.videoPacketsLost; + let oldAudioPacketsLost = stats.audioPacketsLost; + + let oldTotalPacketsLost = oldVideoPacketsLost + oldAudioPacketsLost; + + let packageReceived = stats.inboundRtpList.find(item => item.trackIdentifier.startsWith('ARDAMSv')).packetsReceived + stats.inboundRtpList.find(item => item.trackIdentifier.startsWith('ARDAMSa')).packetsReceived; + let oldPackageReceived = oldStats.inboundRtpList.find(item => item.trackIdentifier.startsWith('ARDAMSv')).packetsReceived + oldStats.inboundRtpList.find(item => item.trackIdentifier.startsWith('ARDAMSa')).packetsReceived; + + // Calculate the packet loss percentage + let packageLostPercentage = 0; + console.log("publishStats:", publishStats); + if (publishStats !== null) { + let deltaPackageLost = oldTotalPacketsLost - totalPacketsLost; + let deltaPackageReceived = oldPackageReceived - packageReceived; + + if (deltaPackageLost > 0) { + packageLostPercentage = ((deltaPackageLost / parseInt(deltaPackageReceived)) * 100).toPrecision(3); + } + } + + // Jitter calculation (average of video and audio jitter) + let videoJitter = stats.inboundRtpList.find(item => item.trackIdentifier.startsWith('ARDAMSv')).jitterBufferDelay; + let audioJitter = stats.inboundRtpList.find(item => item.trackIdentifier.startsWith('ARDAMSa')).jitterBufferDelay; + + let avgJitter = (videoJitter + audioJitter) / 2; + + let rtt = ((parseFloat(stats.videoRoundTripTime) + parseFloat(stats.audioRoundTripTime)) / 2).toPrecision(3); + + // Frame drop rate + let frameDropRate = framesDropped / framesReceived * 100; + + console.log("* Total bytes received: " + totalBytesReceived); + console.log("* Incoming bitrate: " + incomingBitrate.toFixed(2) + " bps"); + console.log("* Total packets lost: " + totalPacketsLost); + console.log("* Frame drop rate: " + frameDropRate.toFixed(2) + "%"); + console.log("* Average jitter: " + avgJitter.toFixed(2) + " ms"); + + let speedTestResult = {}; + + if (rtt > 0.15 || packageLostPercentage > 2.5 || frameDropRate > 5 || avgJitter > 100) { + console.log("-> Your connection quality is poor. You may experience interruptions"); + speedTestResult.message = "Your connection quality is poor. You may experience interruptions"; + } else if (rtt > 0.1 || packageLostPercentage > 1.5 || avgJitter > 50 || frameDropRate > 2.5) { + console.log("-> Your connection is moderate, occasional disruptions may occur"); + speedTestResult.message = "Your connection is moderate, occasional disruptions may occur"; + } else { + console.log("-> Your connection is great"); + speedTestResult.message = "Your connection is Great!"; + } + + speedTestResult.isfailed = false; + speedTestResult.errorMessage = ""; + speedTestResult.progressValue = 100; + + speedTestResult.isfinished = true; + speedTestProgress.current = speedTestResult.progressValue; + setSpeedTestObject(speedTestResult); + + stopSpeedTest(); + } + + function speedTestForPublishWebRtcAdaptorErrorCallback(error, message) { console.log("error from speed test webrtc adaptor callback") //some of the possible errors, NotFoundError, SecurityError,PermissionDeniedError console.log("error:" + error + " message:" + message); - let tempSpeedTestObject = {}; - tempSpeedTestObject.message = speedTestObject.message; - tempSpeedTestObject.isfinished = speedTestObject.isfinished; - tempSpeedTestObject.isfailed = true; - tempSpeedTestObject.errorMessage = "There is an error('"+error+"'). It will try again..." ; - tempSpeedTestObject.progressValue = 0; - speedTestProgress.current = tempSpeedTestObject.progressValue; - - setSpeedTestObject(tempSpeedTestObject); + setSpeedTestObjectFailed("There is an error('"+error+"'). Please try again later..."); + stopSpeedTest(); } function createSpeedTestForPlayWebRtcAdaptor() { @@ -793,13 +868,16 @@ function AntMedia(props) { function speedTestForPlayWebRtcAdaptorInfoCallback(info, obj) { if (info === "initialized") { speedTestPlayStarted.current = false; - speedTestForPlayWebRtcAdaptor.current.play("speedTestStream" + speedTestStreamId.current, "", "", [], "", "", ""); + speedTestForPlayWebRtcAdaptor.current.play("speedTestSampleStream", "", "", [], "", "", ""); } else if (info === "play_started") { console.log("speed test play started") speedTestPlayStarted.current = true; - - } else if (info === "updated_stats") { - console.log("speed test updated stats") + setSpeedTestObjectProgress(20); + speedTestForPlayWebRtcAdaptor.current?.enableStats("speedTestSampleStream"); + } + else if (info === "updated_stats") + { + processUpdatedStatsForPlaySpeedTest(obj); } else if (info === "ice_connection_state_changed") { console.log("speed test ice connection state changed") } @@ -810,7 +888,32 @@ function AntMedia(props) { //some of the possible errors, NotFoundError, SecurityError,PermissionDeniedError console.log("error:" + error + " message:" + message); - //we just check if play_started is received or not to detect playback is successful in speedTestForPlayWebRtcAdaptorInfoCallback + setSpeedTestObjectFailed("There is an error('"+error+"'). Please try again later..."); + + stopSpeedTest(); + } + + function processUpdatedStatsForPlaySpeedTest(statsObj) { + if (speedTestCounter.current === 0) { + statsList.current = []; // reset stats list if it is the first time + } + setSpeedTestObjectProgress(20 + (speedTestCounter.current * 20)); + + speedTestCounter.current = speedTestCounter.current + 1; + setAndFillPlayStatsList(statsObj); + + if (speedTestCounter.current > 3 && statsList.current.length > 3) { + calculateThePlaySpeedTestResult(); + } else { + let tempSpeedTestObject = {}; + tempSpeedTestObject.message = speedTestObject.message; + tempSpeedTestObject.isfinished = false; + tempSpeedTestObject.isfailed = false; + tempSpeedTestObject.errorMessage = ""; + tempSpeedTestObject.progressValue = 20 + (speedTestCounter.current * 20); + speedTestProgress.current = tempSpeedTestObject.progressValue; + setSpeedTestObject(tempSpeedTestObject); + } } function checkAndUpdateVideoAudioSources() { @@ -882,6 +985,60 @@ function AntMedia(props) { } } + function checkAndUpdateVideoAudioSourcesForPublishSpeedTest() { + console.log("Start updating video and audio sources"); + + let { videoDeviceId, audioDeviceId } = getSelectedDevices(); + const isDeviceAvailable = (deviceType, selectedDeviceId) => + devices.some(device => device.kind === deviceType && device.deviceId === selectedDeviceId); + + const updateDeviceIfUnavailable = (deviceType, selectedDeviceId) => { + if (!selectedDeviceId || !isDeviceAvailable(deviceType, selectedDeviceId)) { + const availableDevice = devices.find(device => device.kind === deviceType); + return availableDevice ? availableDevice.deviceId : selectedDeviceId; + } + return selectedDeviceId; + }; + + videoDeviceId = updateDeviceIfUnavailable("videoinput", videoDeviceId); + audioDeviceId = updateDeviceIfUnavailable("audioinput", audioDeviceId); + + const updatedDevices = { videoDeviceId, audioDeviceId }; + console.log("Updated device selections:", updatedDevices); + + setSelectedDevices(updatedDevices); + + const switchDevice = (switchMethod, currentDeviceId, newDeviceId, streamId) => { + if (speedTestForPublishWebRtcAdaptor.current && currentDeviceId !== newDeviceId && streamId) { + speedTestForPublishWebRtcAdaptor.current[switchMethod](streamId, newDeviceId); + } + }; + + try { + switchDevice( + "switchVideoCameraCapture", + getSelectedDevices().videoDeviceId, + videoDeviceId, + publishStreamId + ); + + switchDevice( + "switchAudioInputSource", + getSelectedDevices().audioDeviceId, + audioDeviceId, + publishStreamId + ); + } catch (error) { + console.error( + "Error while switching video and audio sources for the publish speed test adaptor", + error + ); + } + + console.log("Finished updating video and audio sources"); + } + + React.useEffect(() => { setParticipantUpdated(!participantUpdated); if (presenterButtonStreamIdInProcess.length > 0) { @@ -972,7 +1129,7 @@ function AntMedia(props) { ); console.log("UPDATE_PARTICIPANT_ROLE event sent by "+publishStreamId); - webRTCAdaptor?.getSubtracks(roomName, null, 0, 15); + webRTCAdaptor?.getSubtracks(roomName, null, globals.participantListPagination.offset, globals.participantListPagination.pageSize); }, 2000); } @@ -1086,7 +1243,8 @@ function AntMedia(props) { metaData: JSON.stringify({isCameraOn: false}), isPinned: undefined, isScreenShared: undefined, - isFake: true + isFake: true, + status: "livestream" }; allParticipantsTemp["streamId_" + suffix] = broadcastObject; @@ -1137,29 +1295,6 @@ function AntMedia(props) { setIsRecordPluginActive(brodcastStatusMetadata.isRecording); } } - - let participantIds = broadcastObject.subTrackStreamIds; - - //find and remove not available tracks - const temp = {...allParticipants}; - let currentTracks = Object.keys(temp); - currentTracks.forEach(trackId => { - if (!allParticipants[trackId].isFake && !participantIds.includes(trackId)) { - console.log("stream removed:" + trackId); - - delete temp[trackId]; - } - }); - console.log("handleMainTrackBroadcastObject setAllParticipants:"+JSON.stringify(temp)); - setAllParticipants(temp); - setParticipantUpdated(!participantUpdated); - - //request broadcast object for new tracks - participantIds.forEach(pid => { - if (allParticipants[pid] === undefined) { - webRTCAdaptor?.getBroadcastObject(pid); - } - }); } @@ -1170,18 +1305,21 @@ function AntMedia(props) { if(!streamName){ broadcastObject.name = broadcastObject.streamId } - if(metaDataStr === ""){ + if(metaDataStr === "" || metaDataStr === null || metaDataStr === undefined){ broadcastObject.metaData = "{\"isMicMuted\":false,\"isCameraOn\":true,\"isScreenShared\":false,\"playOnly\":false}" } let metaData = JSON.parse(broadcastObject.metaData); let allParticipantsTemp = {...allParticipants}; + let pagedParticipantsTemp = {...pagedParticipants}; broadcastObject.isScreenShared = metaData.isScreenShared; let filteredBroadcastObject = filterBroadcastObject(broadcastObject); allParticipantsTemp[filteredBroadcastObject.streamId] = filteredBroadcastObject; //TODO: optimize + pagedParticipantsTemp[filteredBroadcastObject.streamId] = filteredBroadcastObject; if (!_.isEqual(allParticipantsTemp, allParticipants)) { + setPagedParticipants(pagedParticipantsTemp); setAllParticipants(allParticipantsTemp); setParticipantUpdated(!participantUpdated); } @@ -1196,6 +1334,9 @@ function AntMedia(props) { tempBroadcastObject.bitrate = -1; tempBroadcastObject.updateTime = -1; } + if (tempBroadcastObject.streamId === publishStreamId) { + tempBroadcastObject.name = "You"; + } return tempBroadcastObject; } @@ -1229,6 +1370,10 @@ function AntMedia(props) { useEffect(() => { if (devices.length > 0) { checkAndUpdateVideoAudioSources(); + } else { + navigator.mediaDevices.enumerateDevices().then(devices => { + setDevices(devices); + }); } }, [devices]); // eslint-disable-line react-hooks/exhaustive-deps @@ -1325,34 +1470,61 @@ function AntMedia(props) { } else if (info === "subtrackList") { let subtrackList = obj.subtrackList; let allParticipantsTemp = {}; + let pagedParticipantsTemp = {}; if (!isPlayOnly && publishStreamId) { allParticipantsTemp[publishStreamId] = {name: "You"}; } + + // We are getting the subtracks of the room and adding them to the allParticipantsTemp subtrackList.forEach(subTrack => { let broadcastObject = JSON.parse(subTrack); - try { - let metaData = JSON.parse(broadcastObject.metaData); - broadcastObject.isScreenShared = metaData.isScreenShared; - } catch (e) { - console.log("Metadata can not be parsed:"+broadcastObject.metaData); + handleSubtrackBroadcastObject(broadcastObject); + + let metaDataStr = broadcastObject.metaData; + if(metaDataStr === "" || metaDataStr === null || metaDataStr === undefined){ + metaDataStr = "{\"isMicMuted\":false,\"isCameraOn\":true,\"isScreenShared\":false,\"playOnly\":false}" } + let metaData = JSON.parse(metaDataStr); + broadcastObject.isScreenShared = metaData.isScreenShared; + let filteredBroadcastObject = filterBroadcastObject(broadcastObject); filteredBroadcastObject = checkAndSetIsPinned(filteredBroadcastObject.streamId, filteredBroadcastObject); allParticipantsTemp[filteredBroadcastObject.streamId] = filteredBroadcastObject; + pagedParticipantsTemp[filteredBroadcastObject.streamId] = filteredBroadcastObject; + }); + + // Subtrack list is pagination based, but we need to keep participants who have video track assignments but not in the subtrack list + const participantVTAByStreamId = new Map( + videoTrackAssignments.map(e => [e.streamId, e]) + ); + + Object.keys(allParticipants).forEach(participantId => { + if (participantVTAByStreamId.has(participantId) && !allParticipantsTemp[participantId]) { + allParticipantsTemp[participantId] = allParticipants[participantId]; + } }); + // add fake participants into the new list Object.keys(allParticipants).forEach(streamId => { let broadcastObject = allParticipants[streamId]; if (broadcastObject.isFake === true) { allParticipantsTemp[streamId] = broadcastObject; + pagedParticipantsTemp[streamId] = broadcastObject; } }); + if (!_.isEqual(pagedParticipantsTemp, pagedParticipants)) { + setPagedParticipants(pagedParticipantsTemp); + } if (!_.isEqual(allParticipantsTemp, allParticipants)) { setAllParticipants(allParticipantsTemp); setParticipantUpdated(!participantUpdated); } + } else if (info === "subtrackCount") { + if (obj.count !== undefined) { + setParticipantCount(obj.count); + } } else if (info === "broadcastObject") { if (obj.broadcast === undefined) { return; @@ -1382,7 +1554,7 @@ function AntMedia(props) { localVideoCreate(newLocalVideo); // we need to set the setVideoCameraSource to be able to update sender source after the reconnection webRTCAdaptor.mediaManager.setVideoCameraSource(publishStreamId, webRTCAdaptor.mediaManager.mediaConstraints, null, true); - webRTCAdaptor?.getSubtracks(roomName, null, 0, 15); + webRTCAdaptor?.getSubtracks(roomName, null, globals.participantListPagination.offset, globals.participantListPagination.pageSize); publishReconnected = true; reconnecting = !(publishReconnected && playReconnected); setIsReconnectionInProgress(reconnecting); @@ -1411,7 +1583,8 @@ function AntMedia(props) { setIsPlayed(true); setIsNoSreamExist(false); webRTCAdaptor?.getBroadcastObject(roomName); - webRTCAdaptor?.getSubtracks(roomName, null, 0, 15); + webRTCAdaptor?.getSubtrackCount(roomName, null, null); + webRTCAdaptor?.getSubtracks(roomName, null, globals.participantListPagination.offset, globals.participantListPagination.pageSize); requestVideoTrackAssignmentsInterval(); if (isPlayOnly) { @@ -1543,10 +1716,10 @@ function AntMedia(props) { } } - if (rtt >= 150 || packageLostPercentage >= 2.5 || jitter >= 80) { //|| ((outgoingBitrate / 100) * 80) >= obj.availableOutgoingBitrate + if (rtt >= 0.15 || packageLostPercentage >= 2.5 || jitter >= 0.08) { //|| ((outgoingBitrate / 100) * 80) >= obj.availableOutgoingBitrate console.warn("rtt:" + rtt + " packageLostPercentage:" + packageLostPercentage + " jitter:" + jitter); // + " Available Bandwidth kbps :", obj.availableOutgoingBitrate, "Outgoing Bandwidth kbps:", outgoingBitrate); displayPoorNetworkConnectionWarning("Network connection is weak. You may encounter connection drop!"); - } else if (rtt >= 100 || packageLostPercentage >= 1.5 || jitter >= 50) { + } else if (rtt >= 0.1 || packageLostPercentage >= 1.5 || jitter >= 0.05) { console.warn("rtt:" + rtt + " packageLostPercentage:" + packageLostPercentage + " jitter:" + jitter); displayPoorNetworkConnectionWarning("Network connection is not stable. Please check your connection!"); } @@ -2118,6 +2291,8 @@ function AntMedia(props) { let tempVideoTrackAssignmentsNew = []; + let tempAllParticipants = {...allParticipants}; + // This function checks the case 1 and case 2 currentVideoTrackAssignments.forEach(tempVideoTrackAssignment => { let assignment; @@ -2137,9 +2312,12 @@ function AntMedia(props) { } else { console.log("---> Removed video track assignment: " + tempVideoTrackAssignment.videoLabel); + delete tempAllParticipants[tempVideoTrackAssignment.streamId]; } }); + setAllParticipants(tempAllParticipants); + currentVideoTrackAssignments = [...tempVideoTrackAssignmentsNew]; // update participants according to current assignments @@ -2149,6 +2327,9 @@ function AntMedia(props) { existingAssignment.streamId = vta.trackId; existingAssignment.isReserved = vta.reserved; } + if (!allParticipants[vta.trackId]) { + webRTCAdaptor?.getBroadcastObject(vta.trackId); + } }); checkScreenSharingStatus(); @@ -2181,7 +2362,8 @@ function AntMedia(props) { } else if (eventType === "TRACK_LIST_UPDATED") { console.info("TRACK_LIST_UPDATED -> ", obj); - webRTCAdaptor?.getSubtracks(roomName, null, 0, 15); + webRTCAdaptor?.getSubtrackCount(roomName, null, null); + webRTCAdaptor?.getSubtracks(roomName, null, globals.participantListPagination.offset, globals.participantListPagination.pageSize); } else if (eventType === "UPDATE_PARTICIPANT_ROLE") { console.log("UPDATE_PARTICIPANT_ROLE -> ", obj); @@ -2193,7 +2375,7 @@ function AntMedia(props) { if (updatedParticipant === null || updatedParticipant === undefined) { console.warn("Cannot find broadcast object for streamId: " + notificationEvent.streamId, " in allParticipants. Updated participant list request is sent."); - webRTCAdaptor?.getSubtracks(roomName, null, 0, 15); + webRTCAdaptor?.getSubtracks(roomName, null, globals.participantListPagination.offset, globals.participantListPagination.pageSize); return; } @@ -2208,7 +2390,7 @@ function AntMedia(props) { setRole(notificationEvent.role); } else { console.log("UPDATE_PARTICIPANT_ROLE event received and subtracks are queried"); - webRTCAdaptor?.getSubtracks(roomName, null, 0, 15); + webRTCAdaptor?.getSubtracks(roomName, null, globals.participantListPagination.offset, globals.participantListPagination.pageSize); } setParticipantUpdated(!participantUpdated); } @@ -2295,6 +2477,7 @@ function AntMedia(props) { // we need to empty participant array. if we are going to leave it in the first place. setVideoTrackAssignments([]); setAllParticipants({}); + setPagedParticipants({}); clearInterval(audioListenerIntervalJob); audioListenerIntervalJob = null; @@ -2393,6 +2576,7 @@ function AntMedia(props) { console.log("removeAllRemoteParticipants setAllParticipants:"+JSON.stringify(allParticipantsTemp)); setAllParticipants(allParticipantsTemp); } + setPagedParticipants({}); setParticipantUpdated(!participantUpdated); } @@ -2415,7 +2599,7 @@ function AntMedia(props) { let allParticipantsTemp = {...allParticipants}; allParticipantsTemp[publishStreamId] = { - streamId: publishStreamId, name: "You", isPinned: false, isScreenShared: false + streamId: publishStreamId, name: "You", isPinned: false, isScreenShared: false, status: "livestream" }; if (!_.isEqual(allParticipantsTemp, allParticipants)) { @@ -2482,11 +2666,62 @@ function AntMedia(props) { return isExist; } + React.useEffect(() => { + updateAllParticipantsPagination(globals.participantListPagination.currentPage); + }, [participantCount]); + + function updateAllParticipantsPagination(currentPage) { + if (currentPage <= 0) { + currentPage = 1; + } + + // we calculate the total page count for pagination + if (participantCount === 0) { + // if we are play only user and there is no participant then total page is 1 + globals.participantListPagination.totalPage = 1; + } else { + globals.participantListPagination.totalPage = Math.floor(participantCount / globals.participantListPagination.pageSize) + + (participantCount % globals.participantListPagination.pageSize > 0 ? 1 : 0); + } + + if (currentPage > globals.participantListPagination.totalPage) { + currentPage = globals.participantListPagination.totalPage; + } + + globals.participantListPagination.currentPage = currentPage; + globals.participantListPagination.offset = (globals.participantListPagination.currentPage - 1) * globals.participantListPagination.pageSize; + + // we need to get the subtracks for the new page + webRTCAdaptor?.getSubtracks(roomName, null, globals.participantListPagination.offset, globals.participantListPagination.pageSize); + } + + const fetchImageAsBlob = async (url) => { + const response = await fetch(url); + const blob = await response.blob(); + return URL.createObjectURL(blob); + }; + + function setVirtualBackgroundImage(url) { + if (url === undefined || url === null || url === "") { + return; + } else if (url.startsWith("data:image")) { + setAndEnableVirtualBackgroundImage(url); + } else { + fetchImageAsBlob(url).then((blobUrl) => { + setAndEnableVirtualBackgroundImage(blobUrl); + }); + } + } + function setAndEnableVirtualBackgroundImage(imageUrl) { - let virtualBackgroundImage = document.createElement("img"); - virtualBackgroundImage.id = "virtualBackgroundImage"; - virtualBackgroundImage.style.visibility = "hidden"; - virtualBackgroundImage.alt = "virtual-background"; + let virtualBackgroundImage = document.getElementById("virtualBackgroundImage"); + + if (virtualBackgroundImage === null) { + virtualBackgroundImage = document.createElement("img"); + virtualBackgroundImage.id = "virtualBackgroundImage"; + virtualBackgroundImage.style.visibility = "hidden"; + virtualBackgroundImage.alt = "virtual-background"; + } console.log("Virtual background image url: " + imageUrl); if (imageUrl !== undefined && imageUrl !== null && imageUrl !== "") { @@ -2500,11 +2735,18 @@ function AntMedia(props) { setVirtualBackground(virtualBackgroundImage); webRTCAdaptor?.setBackgroundImage(virtualBackgroundImage); + if (selectedVideoEffect === VideoEffect.VIRTUAL_BACKGROUND) { + // if virtual background is already enabled, no need to enable it again. + return; + } + webRTCAdaptor?.enableEffect(VideoEffect.VIRTUAL_BACKGROUND).then(() => { console.log("Effect: " + VideoEffect.VIRTUAL_BACKGROUND + " is enabled"); + setSelectedVideoEffect(VideoEffect.VIRTUAL_BACKGROUND); setIsVideoEffectRunning(true); }).catch(err => { console.error("Effect: " + VideoEffect.VIRTUAL_BACKGROUND + " is not enabled. Error is " + err); + setSelectedVideoEffect(VideoEffect.NO_EFFECT); setIsVideoEffectRunning(false); }); }; @@ -2532,10 +2774,12 @@ function AntMedia(props) { effectName = VideoEffect.VIRTUAL_BACKGROUND; setIsVideoEffectRunning(true); } - webRTCAdaptor?.enableEffect(effectName).then(() => { + webRTCAdaptor?.enableEffect(effectName)?.then(() => { console.log("Effect: " + effectName + " is enabled"); + setSelectedVideoEffect(effectName); }).catch(err => { console.error("Effect: " + effectName + " is not enabled. Error is " + err); + setSelectedVideoEffect(VideoEffect.NO_EFFECT); setIsVideoEffectRunning(false); }); } @@ -2880,7 +3124,7 @@ function AntMedia(props) { setPresenterButtonDisabled, effectsDrawerOpen, handleEffectsOpen, - setAndEnableVirtualBackgroundImage, + setVirtualBackgroundImage, localVideoCreate, microphoneButtonDisabled, setMicrophoneButtonDisabled, @@ -2915,7 +3159,21 @@ function AntMedia(props) { isBroadcasting, playStats, checkAndSetIsPinned, - setMicAudioLevel + setMicAudioLevel, + updateAllParticipantsPagination, + pagedParticipants, + participantCount, + setParticipantCount, + checkAndUpdateVideoAudioSourcesForPublishSpeedTest, + fetchImageAsBlob, + setAndEnableVirtualBackgroundImage, + setAndFillPlayStatsList, + setAndFillPublishStatsList, + setSpeedTestObjectFailed, + setSpeedTestObjectProgress, + calculateThePlaySpeedTestResult, + processUpdatedStatsForPlaySpeedTest, + speedTestCounter }} > {props.children} diff --git a/react/src/styles/sprite.svg b/react/src/styles/sprite.svg index a0f984ea0..ab5b7cb49 100644 --- a/react/src/styles/sprite.svg +++ b/react/src/styles/sprite.svg @@ -23,7 +23,7 @@ - + @@ -112,7 +112,7 @@ - + diff --git a/react/src/utils.js b/react/src/utils.js index 85cbcf3bd..65f2cb998 100644 --- a/react/src/utils.js +++ b/react/src/utils.js @@ -34,3 +34,13 @@ export function isComponentMode() { export function getRootAttribute(attribute) { return document.getElementById("root")?.getAttribute(attribute); } + +export function parseMetaData(metaData, key) { + if (!metaData) return false; + try { + const parsed = JSON.parse(metaData); + return parsed[key] || false; + } catch { + return false; + } +} \ No newline at end of file diff --git a/react/src/virtualBackground.json b/react/src/virtualBackground.json deleted file mode 100644 index a6bb88ab7..000000000 --- a/react/src/virtualBackground.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "virtualBackgroundImages": [ - "data:image/jpeg;base64,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" - ] -} diff --git a/static/speedTestVideo/speed-test-sample-video.mp4 b/static/speedTestVideo/speed-test-sample-video.mp4 new file mode 100644 index 000000000..4e92af707 Binary files /dev/null and b/static/speedTestVideo/speed-test-sample-video.mp4 differ diff --git a/static/virtualBackgroundImages/README.md b/static/virtualBackgroundImages/README.md new file mode 100644 index 000000000..ed7088af6 --- /dev/null +++ b/static/virtualBackgroundImages/README.md @@ -0,0 +1 @@ +We are putting the virtual background images here because we don't want to increase the size of the war file. We will use the Github as CDN. diff --git a/static/virtualBackgroundImages/virtual-background0.png b/static/virtualBackgroundImages/virtual-background0.png new file mode 100644 index 000000000..df3e3454e Binary files /dev/null and b/static/virtualBackgroundImages/virtual-background0.png differ diff --git a/static/virtualBackgroundImages/virtual-background1.jpg b/static/virtualBackgroundImages/virtual-background1.jpg new file mode 100644 index 000000000..a626e1f85 Binary files /dev/null and b/static/virtualBackgroundImages/virtual-background1.jpg differ diff --git a/static/virtualBackgroundImages/virtual-background2.jpg b/static/virtualBackgroundImages/virtual-background2.jpg new file mode 100644 index 000000000..4a5d7c0fa Binary files /dev/null and b/static/virtualBackgroundImages/virtual-background2.jpg differ diff --git a/static/virtualBackgroundImages/virtual-background3.jpg b/static/virtualBackgroundImages/virtual-background3.jpg new file mode 100644 index 000000000..c8db4db1b Binary files /dev/null and b/static/virtualBackgroundImages/virtual-background3.jpg differ diff --git a/static/virtualBackgroundImages/virtual-background4.jpg b/static/virtualBackgroundImages/virtual-background4.jpg new file mode 100644 index 000000000..b4ace3414 Binary files /dev/null and b/static/virtualBackgroundImages/virtual-background4.jpg differ diff --git a/static/virtualBackgroundImages/virtual-background5.jpg b/static/virtualBackgroundImages/virtual-background5.jpg new file mode 100644 index 000000000..0bcd0f4e0 Binary files /dev/null and b/static/virtualBackgroundImages/virtual-background5.jpg differ diff --git a/static/virtualBackgroundImages/virtual-background7.jpg b/static/virtualBackgroundImages/virtual-background7.jpg new file mode 100644 index 000000000..cec2e69d4 Binary files /dev/null and b/static/virtualBackgroundImages/virtual-background7.jpg differ diff --git a/test/rest_helper.py b/test/rest_helper.py index 953dbe984..6ff173a2f 100644 --- a/test/rest_helper.py +++ b/test/rest_helper.py @@ -34,7 +34,46 @@ def get_broadcasts(self): else: response.raise_for_status() - def get_vod_for(self, streamId): + def create_broadcast_for_play_only_speed_test(self): + url = f"{self.rest_url}/request?_path={self.app_name}/rest/v2/broadcasts/create" + payload = { + "hlsViewerCount": 0, + "dashViewerCount": 0, + "webRTCViewerCount": 0, + "rtmpViewerCount": 0, + "mp4Enabled": 0, + "playlistLoopEnabled": True, + "autoStartStopEnabled": False, + "plannedStartDate": 0, + "playListItemList": [ + { + "type": "VoD", + "streamUrl": "https://github.com/ant-media/conference-call-application/raw/refs/heads/refactorPlayOnlySpeedTest/static/speedTestVideo/speed-test-sample-video.mp4", + "name": "speedTestSampleStream", + "seekTimeInMs": 0, + "durationInMs": 60000 + } + ], + "name": "speedTestSampleStream", + "streamId": "speedTestSampleStream", + "type": "playlist" + } + + response = self.session.post(url, json=payload) + if response.status_code == 200: + json_data = response.json() + print("Broadcast created successfully:", json_data) + return json_data + + def start_broadcast(self, streamId): + url = f"{self.rest_url}/request?_path={self.app_name}/rest/v2/broadcasts/{streamId}/start" + response = self.session.post(url) + if response.status_code == 200: + json_data = response.json() + print("Broadcast started successfully:", json_data) + return json_data + + def getVoDFor(self, streamId): resp = self.session.get(self.rest_url +"/request?_path="+self.app_name+"/rest/v2/vods/list/0/5") print("get_vod_for "+str(streamId+":"+str(resp.text))) json_data = json.loads(resp.text) diff --git a/test/test_join_leave.py b/test/test_join_leave.py index 25cfc0483..7d21456da 100644 --- a/test/test_join_leave.py +++ b/test/test_join_leave.py @@ -58,8 +58,8 @@ def create_participants_with_test_tool(self, participant_name, room, count): process = subprocess.Popen( ["bash", script_path] + parameters, cwd=directory, - stdout=subprocess.DEVNULL, - stderr=subprocess.DEVNULL + #stdout=subprocess.DEVNULL, + #stderr=subprocess.DEVNULL ) return process diff --git a/test/test_main.py b/test/test_main.py index 8358ac9f4..d8f301cfa 100644 --- a/test/test_main.py +++ b/test/test_main.py @@ -18,7 +18,7 @@ os.environ['TEST_APP_NAME'] = app_name_prefix + str(random.randint(100, 999)) #Keep it True to stop tests immediately after a failed test -fail_fast = False +fail_fast = True suite = unittest.TestSuite() suite.addTest(TestDeployment('test_install_app')) @@ -32,8 +32,10 @@ suite.addTests(suite2) +#suite.addTest(TestJoinLeave("test_join_without_camera_mic")) suite.addTest(TestDeployment('test_delete_app')) ret = not unittest.TextTestRunner(verbosity=2, failfast=fail_fast).run(suite).wasSuccessful() sys.exit(ret) + diff --git a/test/test_webinar.py b/test/test_webinar.py index 378aa55d4..e425ae892 100644 --- a/test/test_webinar.py +++ b/test/test_webinar.py @@ -20,8 +20,15 @@ def setUp(self): print(self._testMethodName, " starting...") self.url = os.environ.get('SERVER_URL') self.test_app_name = os.environ.get('TEST_APP_NAME') + self.user = os.environ.get('AMS_USER') + self.password = os.environ.get('AMS_PASSWORD') self.chrome = Browser() self.chrome.init(not self.is_local) + self.chrome.init(True) + self.rest_helper = RestHelper(self.url, self.user, self.password, self.test_app_name) + self.rest_helper.login() + self.rest_helper.create_broadcast_for_play_only_speed_test() + self.rest_helper.start_broadcast("speedTestSampleStream") #self.startLoadTest() def tearDown(self): @@ -136,6 +143,8 @@ def join_room_as_player(self, participant, room, skip_speed_test=False): app = "" handle = self.chrome.open_in_new_tab(self.url+app+"/"+room+"?playOnly=true&role=listener&streamName=" + participant + ("&enterDirectly=true" if skip_speed_test else "")) + wait = self.chrome.get_wait() + #name_text_box = self.chrome.get_element_with_retry(By.ID,"participant_name") #self.chrome.write_to_element(name_text_box, participant) @@ -147,7 +156,7 @@ def join_room_as_player(self, participant, room, skip_speed_test=False): time.sleep(5) speedTestCircularProgress = self.chrome.get_element_with_retry(By.ID,"speed-test-modal-circle-progress-bar", retries=20) - assert(speedTestCircularProgress.is_displayed()) + wait.until(lambda x: speedTestCircularProgress.is_displayed()) time.sleep(5)