GHZMRSupportXR/Assets/Scripts/RTCManager.cs

using Agora.Rtc;
using Agora.Util;
using SC.XR.Unity;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.UI;

public class RTCManager : SingletonMono<RTCManager>
{
   
    public Camera ca;
    public RawImage img;
    Texture2D screenShot;
    byte[] bts;
    /// <summary>
    /// 自身UID
    /// </summary>
    public uint uid;
    /// <summary>
    /// 当前频道号
    /// </summary>
    public string channelName;
  
    [SerializeField]
    private string _appID = "";

    [SerializeField]
    private string _token = "";

    internal IRtcEngine RtcEngine = null;

    public delegate void OnInitDelegate();
    public delegate void OnJoinChannelDelegate();
    public delegate void OnLeaveChannelDelegate();
    public delegate void OnShowViewRawImageDelegate(string uid, RawImage rawImage);
    public delegate void OnShowViewMeshRendererDelegate(string uid, MeshRenderer mesh);
    public delegate void OnShowOneViewRawImageDelegate(RawImage rawImage);
    public delegate void OnMuteLocalAudioStreamDelegate(bool isAudio);
    public delegate void OnMuteLocalVideoStreamDelegate(bool isVideo);
    public delegate void OnMuteRemoteAudioStreamDelegate(string uid, bool isAudio);
    public delegate void OnMuteRemoteVideoStreamDelegate(string uid, bool isVideo);
    public delegate void OnRemoteAudioStateChangedDelegate(string uid,REMOTE_AUDIO_STATE_RTC state, REMOTE_AUIDO_STATE_REASON_RTC reason);
    public delegate void OnRemoteVideoStateChangedDelegate(string uid,REMOTE_VIDEO_STATE_RTC state, REMOTE_VIDEO_STATE_REASON_RTC reason);
    public delegate void OnUserJoinedDelegate(string uid);
    public delegate void OnUserOfflineDelegate(string uid);
    public delegate void OnSetUidDelegate(string uid);
    public delegate void OnSetChannelNameDelegate(string channelName);
    public delegate void OnAddPeeridUidDelegate(string peerid, string uid);
    public delegate void OnRemAtPeeridUidDelegate(string peerid);

    public OnInitDelegate OnInit;
    public OnJoinChannelDelegate OnJoinChannel;
    public OnLeaveChannelDelegate OnLeaveChannel;
    public OnShowViewRawImageDelegate OnShowViewRawImage;
    public OnShowViewMeshRendererDelegate OnShowViewMeshRenderer;
    public OnShowOneViewRawImageDelegate OnShowOneViewRawImage;
    public OnMuteLocalAudioStreamDelegate OnMuteLocalAudioStream;
    public OnMuteLocalVideoStreamDelegate OnMuteLocalVideoStream;
    public OnMuteRemoteAudioStreamDelegate OnMuteRemoteAudioStream;
    public OnMuteRemoteVideoStreamDelegate OnMuteRemoteVideoStream;
    public OnRemoteAudioStateChangedDelegate OnRemoteAudioStateChanged;
    public OnRemoteVideoStateChangedDelegate OnRemoteVideoStateChanged;
    public OnUserJoinedDelegate OnUserJoined;
    public OnUserOfflineDelegate OnUserOffline;
    public OnSetUidDelegate OnSetUid;
    public OnSetChannelNameDelegate OnSetChannelName;
    public OnAddPeeridUidDelegate OnAddPeeridUid;
    public OnRemAtPeeridUidDelegate OnRemAtPeeridUid;

    private void Update()
    {
        PermissionHelper.RequestMicrophontPermission();
        PermissionHelper.RequestCameraPermission();
    }

    /// <summary>
    /// 初始化
    /// </summary>
    public void Init()
    {
        // OnInit();
        InitEngine();
    }

    private void InitEngine()
    {
        _appID = "59a3e20fd9674f53a3422ff48b16db75";
        RtcEngine = Agora.Rtc.RtcEngine.CreateAgoraRtcEngine();

        RTCManagerHandler handler = new RTCManagerHandler(this);
        RtcEngineContext context = new RtcEngineContext(_appID, 0,
                                    CHANNEL_PROFILE_TYPE.CHANNEL_PROFILE_COMMUNICATION,
                                    AUDIO_SCENARIO_TYPE.AUDIO_SCENARIO_DEFAULT);
        //    RtcEngine.SetCameraDeviceOrientation(VIDEO_SOURCE_TYPE.VIDEO_SOURCE_CAMERA, VIDEO_ORIENTATION.VIDEO_ORIENTATION_90);
        RtcEngine.Initialize(context);
        RtcEngine.InitEventHandler(handler);
    }

    public void SetUid(string uid)
    {
        // OnSetUid(uid);
        // UID = uid;
        this.uid = StringToUint(uid);
    }

    public void SetChannelName(string channelName)
    {
       // OnSetChannelName(channelName);
        this.channelName = channelName;
    }

    /// <summary>
    ///  进入房间
    /// </summary>
    public void JoinChannel()
    {
       // OnJoinChannel();

        RtcEngine.EnableAudio();
        RtcEngine.EnableVideo();

        // RtcEngine.DisableAudio();
        //  RtcEngine.DisableVideo();
        VideoEncoderConfiguration config = new VideoEncoderConfiguration();
        config.dimensions = new VideoDimensions(1280, 720);
        config.frameRate = 15;
        config.bitrate = 0;
        //    config.orientationMode = ORIENTATION_MODE.ORIENTATION_MODE_ADAPTIVE;
        RtcEngine.SetVideoEncoderConfiguration(config);
        RtcEngine.SetChannelProfile(CHANNEL_PROFILE_TYPE.CHANNEL_PROFILE_COMMUNICATION);
        RtcEngine.SetClientRole(CLIENT_ROLE_TYPE.CLIENT_ROLE_BROADCASTER);
        // _channelName = roomid;
        RtcEngine.SetExternalVideoSource(true, true, EXTERNAL_VIDEO_SOURCE_TYPE.VIDEO_FRAME, new SenderOptions());

        if (DeviceType.type == "DreamGlass")
            RtcEngine.SetAudioProfile(0, AUDIO_SCENARIO_TYPE.AUDIO_SCENARIO_GAME_STREAMING);
        //  RtcEngine.SetLocalVideoMirrorMode(VIDEO_MIRROR_MODE_TYPE.VIDEO_MIRROR_MODE_ENABLED);
        RtcEngine.JoinChannel(_token, channelName, "", uid);
        Debug.Log("uid  " + uid);
        //RtcEngine.MuteLocalVideoStream(false);
        //RtcEngine.MuteLocalAudioStream(false);
        //RtcEngine.MuteAllRemoteAudioStreams(true);
        //RtcEngine.MuteAllRemoteVideoStreams(true);
        //isRoom = true;
        //MuteLocalAudioStream(CustomInfo.isSendAudio);
        //MuteLocalVideoStream(CustomInfo.isSendVideo);
       // isSendVideo = CustomInfo.isSendVideo;
        StartCoroutine(RenderTexturesScreenCapture());
    }

    
    IEnumerator RenderTexturesScreenCapture()
    {

        Debug.Log("RenderTexturesScreenCapture发送图片1");
        yield return new WaitForEndOfFrame();
        if (screenShot == null)
        {
            screenShot = new Texture2D(1280, 720, TextureFormat.RGBA32, false);
            StartCoroutine(GetRenederFPS());
        }
        while (true)
        {
            // if (isSendVideo)
            //     continue;

            //    img.texture = RemoteRtc.Instance.cam.activeTexture;
            //  RenderTexture.active = ca.activeTexture;

            //  screenShot.ReadPixels(new Rect(0, 0, ca.activeTexture.width, ca.activeTexture.height), 0, 0);
            // screenShot.Apply();
            //Camera.main.targetTexture = null;
            //   RenderTexture.active = null;
            yield return new WaitForSeconds(0.05f);
            if (bts != null)
            {
                //  screenShot = HorizontalFlipTexture(screenShot2);
                var timetick = System.DateTime.Now.Ticks / 10000;
                ExternalVideoFrame externalVideoFrame = new ExternalVideoFrame();
                externalVideoFrame.type = VIDEO_BUFFER_TYPE.VIDEO_BUFFER_RAW_DATA;
                externalVideoFrame.format = VIDEO_PIXEL_FORMAT.VIDEO_PIXEL_RGBA;
                externalVideoFrame.buffer = bts;// screenShot.GetRawTextureData();
                externalVideoFrame.stride = (int)screenShot.width;
                externalVideoFrame.height = (int)screenShot.height;
                externalVideoFrame.rotation = 180;
                externalVideoFrame.cropLeft = 1;
                externalVideoFrame.cropRight = 1;
                externalVideoFrame.timestamp = timetick;
                RtcEngine.PushVideoFrame(externalVideoFrame);
            }
        }
    }
    
    IEnumerator GetRenederFPS()
    {
        while (true)
        {
            var req = AsyncGPUReadback.Request(RemoteRtc.Instance.cam2.activeTexture);
            yield return new WaitUntil(() => req.done);
            if (!req.hasError)
            {

                if (bts == null)
                {
                    bts = new byte[req.layerDataSize];
                }
                req.GetData<byte>().CopyTo(bts);
                //   screenShot.LoadRawTextureData(bts);
                //  screenShot.Apply();
                //  tex.SetPixels32(req.GetData<Color32>().ToArray());
                //  img.texture = screenShot;
            }
            else
            {
                Debug.LogError("Error AsyncGPUReadbackRequest.hasError");
            }
        }
    }

    /// <summary>
    ///  退出房间
    /// </summary>
    public void LeaveChannel()
    {
        //OnLeaveChannel();
        int msg = RtcEngine.LeaveChannel();
        switch (msg)
        {
            case 0:
                Debug.Log( "成功退出频道： " + channelName);
                break;
            default:
                Debug.Log("退出频道失败： " + msg);
                break;
        }

      
    }

    
    /// <summary>
    ///  显示用户画面
    /// </summary>
    /// <param name="uid"> 用户的UID</param>
    /// <param name="rawImage"> 需要显示的RawImage</param>
    public void ShowViewRawImage( string peerId, RawImage rawImage)
    {
        //OnShowViewRawImage(uid, rawImage);

        MakeVideoView(StringToUint(peerId), rawImage, this.channelName);
    }
    /// <summary>
    ///  显示用户画面
    /// </summary>
    /// <param name="uid"> 用户的UID</param>
    /// <param name="mesh"> 需要显示的Mesh</param>
    public void ShowViewMeshRenderer(string uid, MeshRenderer mesh)
    {
        OnShowViewMeshRenderer(uid, mesh);
    }
   
    /// <summary>
    ///  开关自身音频
    /// </summary>
    /// <param name="isAudio"></param>
    public void MuteLocalAudioStream(bool isAudio)
    {
        //OnMuteLocalAudioStream(isAudio);

        int msg = RtcEngine.MuteLocalAudioStream(!isAudio);

        //  int msg = RtcEngine.EnableLocalAudio(isAudio);
        switch (msg)
        {
            case 0:
                Debug.Log(isAudio ? "打开本地音频成功" : "关闭本地音频成功 ");
                break;
            default:
                Debug.LogError("开关本地音频失败： " + msg);
                break;
        }
    }
    /// <summary>
    ///  开关自身视频
    /// </summary>
    /// <param name="isVideo"></param>
    public void MuteLocalVideoStream(bool isVideo)
    {
       // OnMuteLocalVideoStream(isVideo);
        int msg = RtcEngine.MuteLocalVideoStream(!isVideo);
        switch (msg)
        {
            case 0:
                Debug.Log(isVideo ? "打开本地视频成功 " : "关闭本地视频成功 ");
                break;
            default:
                Debug.LogError("开关本地视频失败： " + msg);
                break;
        }
    }
    /// <summary>
    ///  订阅/取订 用户音频
    /// </summary>
    /// <param name="uid"></param>
    /// <param name="isAudio"></param>
    public void MuteRemoteAudioStream(string peerid, bool isAudio)
    {
     //   OnMuteRemoteAudioStream(uid, isAudio);
     //   
        int msg = RtcEngine.MuteRemoteAudioStream(StringToUint(peerid), !isAudio);

        switch (msg)
        {
            case 0:
                Debug.Log(isAudio ? "订阅远端音频成功" : "取订远端音频成功 ");
                break;
            default:
                Debug.LogError("远端音频失败： " + msg);
                break;
        }
    }

    /// <summary>
    ///  订阅/取订 用户视频
    /// </summary>
    /// <param name="uid"></param>
    /// <param name="isVideo"></param>
    public void MuteRemoteVideoStream(string peerid, bool isVideo)
    {
     //   OnMuteRemoteVideoStream(uid, isVideo);

        int msg = RtcEngine.MuteRemoteVideoStream(StringToUint(peerid), !isVideo);
        switch (msg)
        {
            case 0:
                Debug.Log(isVideo ? "订阅远端视频成功" : "取订远端视频成功 ");
                break;
            default:
                Debug.LogError("远端视频失败： " + msg);
                break;
        }
    }
    /// <summary>
    /// 用户音频状态发生变化的回调
    /// </summary>
    /// <param name="uid"></param>
    /// <param name="state"> 音频状态 </param>
    public void RemoteAudioStateChanged(string uid ,REMOTE_AUDIO_STATE state, REMOTE_AUDIO_STATE_REASON reason)
    {
        OnRemoteAudioStateChanged(uid, (REMOTE_AUDIO_STATE_RTC)state, (REMOTE_AUIDO_STATE_REASON_RTC)reason);
    }
    /// <summary>
    /// 用户视频状态发生变化的回调
    /// </summary>
    /// <param name="uid"></param>
    /// <param name="state"> 视频状态 </param>
    public void RemoteVideoStateChanged(string uid ,REMOTE_VIDEO_STATE state , REMOTE_VIDEO_STATE_REASON reason)
    {
        OnRemoteVideoStateChanged(uid, (REMOTE_VIDEO_STATE_RTC)state, (REMOTE_VIDEO_STATE_REASON_RTC)reason);
    }

    /// <summary>
    ///  有用户进入频道的回调
    /// </summary>
    /// <param name="uid"></param>
    public void UserJoined(string uid)
    {
        OnUserJoined(uid);
    }

    /// <summary>
    ///  有用户退出频道的回调
    /// </summary>
    /// <param name="uid"></param>
    public void UserOffline(string uid)
    {
        OnUserOffline(uid);
    }

    private uint StringToUint(string value)
    {
        //byte[] bytes = Encoding.ASCII.GetBytes(value);

        return (uint)int.Parse(value);
        // return BitConverter.ToUInt32(bytes);
    }


    internal static void MakeVideoView(uint uid, RawImage rawImage, string channelId = "")
    {
        Debug.Log("MakeVideoView   " + uid);
        //var go = GameObject.Find(uid.ToString());
        //if (!ReferenceEquals(go, null))
        //{
        //    return; // reuse
        //}

        // create a GameObject and assign to this new user
        var videoSurface = MakeImageSurface(rawImage);
        // var videoSurface = MakePlaneSurface(uid.ToString());
        if (ReferenceEquals(videoSurface, null)) return;
        // configure videoSurface
        if (uid == 0)
        {
            //  videoSurface.SetForUser(uid, channelId);
        }
        else
        {
            videoSurface.SetForUser(uid, channelId, VIDEO_SOURCE_TYPE.VIDEO_SOURCE_REMOTE);
        }

        //videoSurface.OnTextureSizeModify += (int width, int height) =>
        //{
        //    float scale = (float)height / (float)width;
        //    videoSurface.transform.localScale = new Vector3(-5, 5 * scale, 1);
        //    Debug.Log("OnTextureSizeModify: " + width + "  " + height);
        //};

        videoSurface.SetEnable(true);
        //  AgoraVideoAudioManager.Instance.EnableLocalVideo(false);

    }


    private static VideoSurface MakeImageSurface(RawImage rawImage)
    {
        // make the object draggable
        if (rawImage.gameObject.GetComponent<UIElementDrag>() != null)
            Destroy(rawImage.gameObject.GetComponent<UIElementDrag>());
        rawImage.gameObject.AddComponent<UIElementDrag>();

        // configure videoSurface

        if (rawImage.gameObject.GetComponent<VideoSurface>() != null)
            Destroy(rawImage.gameObject.GetComponent<VideoSurface>());
        var videoSurface = rawImage.gameObject.AddComponent<VideoSurface>();

        return videoSurface;
    }

    internal static void OnUserJoined_Agora(uint uid)
    {
        // _videoSample.Log.UpdateLog(string.Format("OnUserJoined uid: ${0} elapsed: ${1}", uid, elapsed));
        // Debug.Log(string.Format("OnUserJoined uid: ${0} elapsed: ${1}", uid, elapsed))

        RTCManager.Instance.UserJoined(uid.ToString());

    }

    internal static void OnRemoteVideoStateChanged_Agora(uint uid, REMOTE_VIDEO_STATE state, REMOTE_VIDEO_STATE_REASON
        reason)
    {
        RTCManager.Instance.RemoteVideoStateChanged(uid.ToString(), state, reason);
    }
    internal static void OnRemoteAudioStateChanged_Agora(uint uid, REMOTE_AUDIO_STATE state, REMOTE_AUDIO_STATE_REASON reason)
    {
        RTCManager.Instance.RemoteAudioStateChanged(uid.ToString(), state, reason);
    }
}
public class RTCManagerHandler : IRtcEngineEventHandler
{
    private readonly RTCManager _videoSample;

    internal RTCManagerHandler(RTCManager videoSample)
    {
        _videoSample = videoSample;
    }

    public override void OnError(int err, string msg)
    {
        
    }

    public override void OnJoinChannelSuccess(RtcConnection connection, int elapsed)
    {
        int build = 0;
        Debug.Log("Agora: OnJoinChannelSuccess ");
      ////  _videoSample.Log.UpdateLog(string.Format("sdk version: ${0}",
      //   //   _videoSample.RtcEngine.GetVersion(ref build)));
      //  //_videoSample.Log.UpdateLog(string.Format("sdk build: ${0}",
      // //   build));
      //  //_videoSample.Log.UpdateLog(
      //      string.Format("OnJoinChannelSuccess channelName: {0}, uid: {1}, elapsed: {2}",
      //                      connection.channelId, connection.localUid, elapsed));

      //  //  _videoSample.ClickSelf();
      //  // AgoraVideoAudioManager.MakeVideoView(0);

    }

    public override void OnLeaveChannel(RtcConnection connection, RtcStats stats)
    {
        // _videoSample.Log.UpdateLog("OnLeaveChannel");
        //RTCManager.DestroyVideoView(0);
    }

    public override void OnClientRoleChanged(RtcConnection connection, CLIENT_ROLE_TYPE oldRole, CLIENT_ROLE_TYPE newRole)
    {
        //_videoSample.Log.UpdateLog("OnClientRoleChanged");
    }

    public override void OnUserJoined(RtcConnection connection, uint uid, int elapsed)
    {
        Debug.Log(string.Format("OnUserJoined uid: ${0} elapsed: ${1}", uid, elapsed));
        // _videoSample.Log.UpdateLog(string.Format("OnUserJoined uid: ${0} elapsed: ${1}", uid, elapsed));
        RTCManager.OnUserJoined_Agora(uid);
        //   AgoraVideoAudioManager.MakeVideoView(uid, _videoSample.GetChannelName());
    }

    public override void OnUserOffline(RtcConnection connection, uint uid, USER_OFFLINE_REASON_TYPE reason)
    {
       // _videoSample.Log.UpdateLog(string.Format("OnUserOffLine uid: ${0}, reason: ${1}", uid,
       //     (int)reason));
        //  AgoraVideoAudioManager.DestroyVideoView(uid);
    }


    public override void OnRemoteVideoStateChanged(RtcConnection connection, uint remoteUid, REMOTE_VIDEO_STATE state, REMOTE_VIDEO_STATE_REASON reason, int elapsed)
    {
        RTCManager.OnRemoteVideoStateChanged_Agora(remoteUid, state, reason);
    }

    public override void OnRemoteAudioStateChanged(RtcConnection connection, uint remoteUid, REMOTE_AUDIO_STATE state, REMOTE_AUDIO_STATE_REASON reason, int elapsed)
    {
        RTCManager.OnRemoteAudioStateChanged_Agora(remoteUid, state, reason);
    }
}