Kurento 客户端

已于 2023-09-19 09:54:20 修改
阅读量466 收藏
点赞数
文章标签： kurento
于 2020-09-15 06:55:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baeeqregist/article/details/108591947
版权 
/*
* 该API配合服务器端API模块使用
* hhMedia/svr/nodesvr.js
* */


/*

 */


function TKmsClient(){
    this.config={
        apiUrl :"https://**.**.cn:20020/hhapi" ,
        wsUrl:"wss://**.**..cn:20020/hhws" ,
        kurentUrl:"wss://**.**..cn:8433/kurento",
        defaultPeerOptions:{
            configuration: {
                "iceServers":[
                    {
                        urls:"stun:223.68.161.139:3478"
                    },
                    {
                        urls:["turn:223.68.161.139:3478"],
                        username:"kurento",
                        credential: "kurento"
                    }
                ]
            },
            mediaConstraints:{
               audio: true,
               video: {width: {exact: 1280}, height: {exact: 720}}
            },
            localVideo: null ,
            remoteVideo: null
        }
    };
    this.kmsPeerTypes={
        send:kurentoUtils.WebRtcPeer.WebRtcPeerSendonly,
        rec:kurentoUtils.WebRtcPeer.WebRtcPeerRecvonly,
        sendRec:kurentoUtils.WebRtcPeer.WebRtcPeerSendrecv
    }
    this.events={
        onWsOpen: function (ws) {} ,
        onWsClose: function (ws) {} ,
        onWsMsg: function (ws, msg) {} ,
    };
    this.objs={
        kurentClient:null,
        ws:null
    };
    this.callBack = function( callback , ps){
        if( callback){
            try{
                callback(ps);
            }
            catch (er) {
                console.log(er)
            }
        }
    }
}
TKmsClient.prototype.callApi = function( ac , data , callback){
    var me = this;
    try{
        var aUrl = me.config.apiUrl+"/"+ac+"?tm="+( new Date()).getTime().toString();
        $.ajax({
            url: aUrl ,
            data : data ,
            type:"POST",
            success: function (resData) {
                try{
                    var res = JSON.parse(resData);
                    me.callBack(callback , res);
                }
                catch (erSuccess) {
                    console.log(erSuccess);
                }
            },
            error: function (er0, er1  ) {
                try{
                    var res = JSON.parse(resData);
                    me.callBack(callback , {er0:er0 , er1:er1});
                }
                catch (erSuccess) {
                    console.log(erSuccess);
                }
            }
        })
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.dbQuery = function( appName , key , ps , callback){
    var me = this;
    try{
        var data ={
            app:appName ,
            key: key ,
            ps:JSON.stringify(ps)
        };
        var ac ="queryArray";
        me.callApi(ac , data , callback);
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.dbQueryDict = function( appName , key , ps , callback){
    var me = this;
    try{
        var data ={
            app:appName ,
            key: key ,
            ps:JSON.parse(ps)
        };
        var ac ="queryDict";
        me.callApi(ac , data , callback);
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.openWs = function( onOpen , onClose , onMsg ){
    var me = this;
    try{
        var ws = new WebSocket(me.config.wsUrl);
        ws.onopen = function(){
        　　//当WebSocket创建成功时，触发onopen事件
           console.log("wss is openned!");
            if( onOpen){
                try{
                    onOpen(ws);
                }
                catch (e1) {
                    console.log(e1);
                }
            }
        };
        ws.onerror = function(){
        　　try{
                ws.close();
            }
            catch (e1) {
                console.log(e1);
            }
        };
        ws.onclose = function(){
        　　try{
                if( onClose){
                    try{
                        onClose(ws);
                    }
                    catch (e1) {
                        console.log(e1);
                    }
                }
            }
            catch (e1) {
                console.log(e1);
            }
        };
        ws.onmessage = function(e){
        　　//当客户端收到服务端发来的消息时，触发onmessage事件，参数e.data包含server传递过来的数据
        　　console.log(e.data);
            try{
                var msg = JSON.parse(e.data);
                if( msg.id == "s2cSetWsId" ){
                    ws.wsId = msg.body.wsId;
                }
                else  if( onMsg){
                    onMsg(ws,msg);
                }
            }
            catch (err) {
                console.log(err);
            }
        };
        me.objs.ws = ws;
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.wsSendMsg = function( id , body ){
    var me = this;
    try{
        if( me.objs.ws){
            me.objsws.send(JSON.parse({
                id:id,
                body:body
            }));
        }
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.wsSetInfo = function( key, data ){
    var me = this;
    try{
        me.wsSendMsg("setWsInfo",{wsId: me.objs.ws.wsId ,  key:key, data:data});
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.wsGetInfo = function( key, callback ){
    var me = this;
    try{
        me.callApi("getWsInfo",{wsId: me.objs.ws.wsId, key:key}, callback);
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.wsMutilcast = function( groupId , data , callback ){
    var me = this;
    try{
        me.wsSendMsg("wsMutilcast",{groupId:groupId , data:data});
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.wsSetGroup = function( groupId , callback ){
    var me = this;
    try{
        me.wsSendMsg("wsMutilcast",{wsId: me.objs.ws.wsId,  groupId:groupId , data:data});
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.ioSetData = function(  key , data , callback ){
    var me = this;
    try{
        me.callApi('setData',{key:key, data:data}, callback);
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.ioGetData = function( key , callback ){
    var me = this;
    try{
        me.callApi('getData',{key:key, data:data}, callback);
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.kmsGetClient = function( callback){
    var me = this;
    try{
        if (me.objs.kurentClient){
            me.callBack(callback, {res:me.objs.kurentClient, error:null});
        }
        else {
            kurentoClient(me.config.kurentUrl, function (error, client) {
                if (client) {
                    me.objs.kurentClient = client;
                }
                me.callBack(callback, {res:client, error:error});
            });
        }
    }
    catch (er) {
        console.log(er);
    }
};
TKmsClient.prototype.kmsBindPeerAndEndpoint = function ( peer , endpoint,  callback) {
    var me = this;
    try{
        if( endpoint && peer){
            peer.generateOffer(function (errorPeerGenerateOffer, sdpOffer) {
                if( errorPeerGenerateOffer && callback){
                    callback( errorPeerGenerateOffer , null);
                }
                else {
                    endpoint.processOffer(sdpOffer, function (errorSdpOffer, sdpAnswer) {
                        if (errorSdpOffer && callback) {
                            console.log("process sdpOffer error.", errorSdpOffer)
                            callback(errorSdpOffer, null);
                        } else {
                            me.setCandidateEvent(peer , endpoint);
                            peer.processAnswer(sdpAnswer);
                            endpoint.gatherCandidates(function (errorGatherCandidates) {
                                if (errorGatherCandidates && callback) {
                                    console.log('webRtcPoint gatherCandidates error.', errorGatherCandidates)
                                    callback(errorGatherCandidates, null);
                                }
                                else{
                                    peer.endpoint = endpoint;
                                    endpoint.peer = peer;
                                    if( callback) {
                                        callback(null, {endpoint: endpoint, peer: peer});
                                    }
                                }
                            });
                        }
                    });
                }
            });
        }
        else {
            if( callback) {
                callback({ error:"endPoint or peer is null."}, null);
            }
        }
    }
    catch (er) {
        console.log(er,"bindPeerAndEndpoint error.");
    }
};
TKmsClient.prototype.setCandidateEvent = function( peer , endpoint   ){
    var me = this;
    try{
        if( peer && endpoint){
            endpoint.on('OnIceCandidate', function(event) {
                var candidate = event.candidate;
                peer.addIceCandidate(candidate);
                console.log('candidate w->p')
            });
            peer.on('icecandidate', function(candidate){
                var iceCandidate = kurentoClient.register.complexTypes.IceCandidate(candidate);
                endpoint.addIceCandidate(iceCandidate);
                console.log('candidate p->w')

            });
        }
    }
    catch (er) {
        console.log(er,"setCandidateEvent error.");
    }
};

TKmsClient.prototype.kmsFreeEndpoint = function ( endpoint) {
    var me = this;
    try{
        if( endpoint  ){
            endpoint.release(function (err) {
                console.log('free endpoint.')
            });
            endpoint = null;
        }
    }
    catch (er) {
        console.log(er,"freeEndpoint error.");
    }
};
TKmsClient.prototype.kmsFreePeer = function ( peer) {
    var me = this;
    try{
        if( peer  ){
            if( peer.peerConnection){
                peer.peerConnection.close();
            }
            peer.dispose();
            peer = null;
        }
    }
    catch (er) {
        console.log(er,"freePeer error.");
    }
};
TKmsClient.prototype.kmsCreatePeer = function ( localVideo , remoteVideo , sendSource, beforeCreateCallback ,callback) {
    var me = this;
    try{
        var opts= JSON.parse(JSON.stringify(me.config.defaultPeerOptions));

        var localFlag = false;
        if( localVideo && (localVideo!=null)){
            opts.localVideo = localVideo;
            localFlag = true;
        }
        var remoteFlag = false;
        if( remoteVideo && (remoteVideo!=null)){
            opts.remoteVideo = remoteVideo;
            remoteFlag = true;
        }
        if( sendSource=="window" || sendSource=="screen" || sendSource=="desktop"){
            opts.sendSource = sendSource;
        }
        var createFactory = null;
        if( (localFlag)&&(!remoteFlag) ){
            createFactory = kurentoUtils.WebRtcPeer.WebRtcPeerSendonly;
        }
        else  if( (!localFlag)&&(remoteFlag) ){
            createFactory = kurentoUtils.WebRtcPeer.WebRtcPeerRecvonly;
        }
        else  if( (localFlag)&&(remoteFlag) ){
            createFactory = kurentoUtils.WebRtcPeer.WebRtcPeerSendrecv;
        }
        if( beforeCreateCallback){
            try{
                beforeCreateCallback(opts);
            }
            catch (e0) {
                console.log(e0)
            }
        }
        var res ={
            error:null,
            peer:null
        }
        if( createFactory){
            var peer = createFactory(opts , function (err) {
                //opts.video ={ width:1280, height:720};
                var peerId = "peer_"+( new Date()).getTime().toString();
                peer.clientId = peerId;
                peer.peerConnection.addEventListener('iceconnectionstatechange', function(event){
                    if( event){
                        console.log('create peer error.', event);
                    }
                    else {
                        if (peer && peer.peerConnection) {
                            console.log("oniceconnectionstatechange -> " + peer.peerConnection.iceConnectionState);
                            console.log('icegatheringstate -> ' + peer.peerConnection.iceGatheringState);
                        }
                    }
                });
                res.error = err;
                res.peer = peer;
                me.callBack(callback, res);
            })
        }
        else{
            res.error ="createFactory error.";
            me.callBack(callback, res);
        }
    }
    catch (er) {
        console.log(er,"createPeer error.");
    }
};
TKmsClient.prototype.kmsGetAvDevices = function ( callback) {
    var me = this;
    try{
        var res ={};
/*
        navigator.mediaDevices.enumerateDevices(function (devs) {

            for( var i=0;i<devs.length;i++){
                var item = devs[i];
                if( !res[item.kind]){
                    res[item.kind]=[]
                }
                res[item.kind].push(item);
            }
            console.log(res);
            if (callback){
                callback({error: null, devices:res});
            }
        });
*/
        navigator.mediaDevices.enumerateDevices().then(function (devs) {
            for( var i=0;i<devs.length;i++){
                var item = devs[i];
                if( !res[item.kind]){
                    res[item.kind]=[]
                }
                res[item.kind].push(item);
            }
            console.log(res);
            if (callback){
                callback({error: null, devices:res});
            }
        });
    }
    catch (er) {
        console.log(er,"createPeer error.");
    }
};
TKmsClient.prototype.changeCamera = function ( peer, newCameraDeviceId , callback) {
    var me = this;
    try{
        var result={error:null , res: null}
        //var constraints = {video: {deviceId: {exact: newCameraDeviceId}}};
        var constraints = {video: {deviceId: newCameraDeviceId}};
        var sender = null;
        navigator.mediaDevices.getUserMedia(constraints).then(function (stream) {
            try{
                if( stream){
                    let videoTrack = stream.getVideoTracks()[0];
                    peer.localVideo.srcObject = stream;
                    sender = peer.peerConnection.getSenders().find(function (s) {
                        return s.track.kind == videoTrack.kind;
                    });
                    sender.track.stop();
                    sender.replaceTrack(videoTrack);
                    result.res = constraints;
                    if( callback){
                        callback(result);
                    }
                }
                else{
                    if( callback){
                        result.error = "stream is null";
                        callback(result);
                    }
                }
            }
            catch (er) {
                console.log(er);
            }
        });
    }
    catch (er) {
        console.log(er);
    }
}
TKmsClient.prototype.kmsShareScreen = function ( peer , callback) {
    var me = this;
    try{
        if (navigator.mediaDevices.getDisplayMedia) {
            navigator.mediaDevices.getDisplayMedia({video:true}).then(
                function (stream) {
                    let videoTrack = stream.getVideoTracks()[0];
                    peer.localVideo.srcObject = stream;
                    sender = peer.peerConnection.getSenders().find( function (s) {
                        return s.track.kind == videoTrack.kind;
                    });
                    sender.track.stop();
                    sender.replaceTrack(videoTrack);
                    if( callback) {
                        callback( );
                    }
                }
            )
        }
    }
    catch (er) {
        console.log(er);
    }
}
TKmsClient.prototype.kmsCreatePeerEnd = function ( pipe, shareScreenFlag , localVideo , remoteVideo, callback) {
    var me = this;
    try{
        var result={
            error:null,
            peer: null,
            endpoint:null
        };
        var shareOpts = shareScreenFlag?"screen":"webcam";
        me.kmsCreatePeer(localVideo, remoteVideo , shareOpts, null , function (res) {
            if( res.error ){
                result.error = res.error;
                me.callBack(callback,result);
            }
            else{
                result.peer = res.peer;
                pipe.create("WebRtcEndpoint", function ( errEnd , end) {
                    result.endpoint = end;
                    if( errEnd){
                        result.error = errEnd;
                        me.callBack(callback , result);
                    }
                    else{
                        me.kmsBindPeerAndEndpoint(res.peer , end, function () {
                            me.callBack(callback , result);
                        })
                    }
                })
            }
        })
    }
    catch (er) {
        console.log(er);
    }
}
陈鹏-hhuiot
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Kurento实战之五：媒体播放
m0_66144992的博客
01-05 509
/** 标准的WebSocket处理类绑定 @param registry */ @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(handler(), “/player”); } public static void main(String[] args) throws Exception { SpringApplication.run
Kurento Utils JS
weixin_34107739的博客
02-17 1430
2019独角兽企业重金招聘Python工程师标准>>> ...
kurento-client
04-18
版权所有:copyright:2013-2016 。 在许可下获得。 kurento-hello-world Kurento JavaScript教程：Hello World（环回中的WebRTC）。 运行本教程 为了运行本教程，请阅读以下 。 什么是Kurento Kurento是一个开放源代码软件项目，提供了一个平台，该平台适用于创建具有高级实时通信功能的模块化应用程序。 要了解有关Kurento的更多信息，请访问Kurento项目网站： ://www.kurento.org。 Kurento是部分 。 有关FIWARE和Kurento关系的更多信息，请查看 Kurento是研究计划的一部分。 文献资料 Kurento项目提供了详细的文档，包括教程，安装和开发指南。 可以在readthedocs.org上找到该文档的简化版本。 该开放API规范又名Kurento协议，也可在apiary.io
前端项目-kurento-client.zip
09-03
前端项目-kurento-client,Media API for the Kurento Web SDK
Kurento应用安全
weixin_34090643的博客
02-17 388
2019独角兽企业重金招聘Python工程师标准>>> ...
视频服务器(7) Kurento[2] js客户端
llhswwha的专栏
11-08 2355
目录 一、获取js文件 二、通信 1.跨域问题 2.java.io.EOFException:null 3.websocket发送文本长度问题 4.wss问题 5.websocket连接还没建立就点击Start按钮 三、页面修改 之前的项目是java的，我需要的是纯前端的js客户端，通过js客户端播放视频，然后用unity打包的webgl和js客户端交互，实现在unity的web...
kurento6.9.0 client java的使用方法（kurento-hello-world）
Java_lilin的专栏
03-11 1331
本文基于kurento6.9.0安装 交流群:261074724 安装文档参考官方的 下载kurento-tutorial-java-master https://github.com/Kurento/kurento-tutorial-java 首先在maven项目种搭建号spring4 的websouket和mvc 创建一个新的socket @Configuration ...
KurentoRoomClient:适用于Windows的Kurento Room Client C ++
04-27
KurentoRoomClient 项目介绍 {以下是平台说明，您可以替换为您的项目简介 是开源中国推出的基于 Git 的代码托管平台（同时支持 SVN）。专为开发者提供稳定、高效、安全的云端软件开发协作平台 无论是个人、团队、或是企业，都能够用码云实现代码托管、项目管理、协作开发。企业项目请看 } 软件架构 软件架构说明 安装教程 xxxx xxxx xxxx 使用说明 xxxx xxxx xxxx 参与贡献 Fork 本项目 新建 Feat_xxx 分支 提交代码 新建 Pull Request 码云特技 使用 Readme_XXX.md 来支持不同的语言，例如 Readme_en.md, Readme_zh.md rainstream官方博客
kurento-utils-js:[未维护]
05-15
版权所有2018 。 在许可下获得。 Kurento Utils用于Node.js和浏览器 kurento-utils-js是一个浏览器库，可用于简化对象的创建和处理，以控制浏览器的 。 :warning: 警告 该库未积极维护。 它是为简化而编写的，并且对于更高级的用法有一些缺点。 对于实际应用程序，我们建议避免使用此库，而应直接根据浏览器的WebRTC API编写JavaScript代码。 安装说明 确保在系统中安装了和 ： curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash - sudo apt-get install -y nodejs sudo npm install -g bower 要安装该库，建议从NPM存储库中进行安装： npm install kurento-utils 或者，您可以使用git下载代码并手
Kurento Utils JS使用时视频无法播放的坑
potato_ubisoft的博客
09-27 544
如题 需要设置video标签的autoplay属性，否则无法播放。 <video ref="videoPanel" :id="`video${deviceId}`" autoplay class="player__video"></video>
kurento-client-filters-js:Kurento 客户端过滤器 javascript 生成
05-30
kurento 客户端过滤器 kurento 媒体服务器的过滤器实现 此存储库托管模块过滤器的描述符文件。
kurento-client-php:当前PHP客户端
05-10
Kurento客户端PHP Kurento Kurento客户端PHP库，实现了客户端安装安装此库的最简单方法是使用composer 。 更新您的composer.json "repositories" : [ { "type" : "vcs" , "url" : ...
kurento-client-bower:[只读]适用于Kurento Media Server的自动生成JavaScript客户端API
05-07
适用于BowerJavaScript Kurento客户端该项目包含[Bower]JavaScript Kurento Client的实现。 可以从克隆该项目的源代码。安装说明确保在系统中安装了和[Bower]： curl -sL https://deb.nodesource.com/setup_8.x | ...
kurento
03-19
演示应用程序，展示如何使用Kurento Java客户端。 关于库伦托 Kurento是一个开放源代码软件项目，提供了一个平台，该平台适用于创建具有高级实时通信功能的模块化应用程序。要了解有关Kurento的更多信息，请访问...
kurento-client-core-js:[只读]适用于Kurento Media Server的自动生成JavaScript客户端API
05-07
模块“核心”描述：Kurento Media ServerJavaScript客户端API什么是Kurento Kurento是一个开放源代码软件项目，提供了一个平台，该平台适用于创建具有高级实时通信功能的模块化应用程序。 要了解有关Kurento的更多...
使用Kurento框架构建Java客户端的WebRTC应用程序（一）
每天多一点
06-02 5698
第一步: 安装Kurento媒体服务器KMS明确支持Ubuntu的两个长期支持（LTS）发行版：Ubuntu 14.04（Trusty）和Ubuntu 16.04（Xenial）。仅支持64位版本。目前，KMS的主要开发环境是Ubuntu 16.04（Xenial）。本地安装（Ubuntu 16.04）1. 打开一个终端并复制以下命令：＃KMS for Ubuntu 16.04（Xenial） D...
Kurento架构
zpz_123123的专栏
03-12 608
https://www.jianshu.com/p/8c31479e6083 参考 kurento architecture 架构 信令部分 和 媒体部分 Kurento架构，信令和媒体层 信令层: 提供媒体协商能力、QoS参数化、呼叫建立、用户注册、用户显现等的一些模块组成了信令层。（The parts of the system in charge of the manag...
Kurento简介
李天泉
07-31 8312
WebRTC是一项开源技术,它能够通过JavaScript API实现网页浏览器间的实时通信。它被认为是一种P2P技术,不用通过任何类型的媒体中继, 能实现浏览器间的实时通信。这种方式能足以实现一些基本的应用,但是有些功能,如组通信,媒体流录制,媒体广播或媒体转码是很难实现的。基于这个原因,很多应用还是需要有媒体服务器。  ![Peer-to-peer WebRTC approach vs. We...
通过kurento 搭建webrtc服务器
最新发布
05-20
Kurento是一种流媒体服务器，可以用于搭建WebRTC服务器。下面是一些基本的步骤： 1. 安装Kurento媒体服务器。可以从官方网站下载最新版本的Kurento。 2. 配置Kurento媒体服务器。具体的配置过程会因为你的操作系统...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值