+ 视频跟随，视频喊话

+ stomp 协议

bd-location/Dockerfile

@@ -1,5 +1,6 @@
 # 使用官方的 OpenJDK 8 镜像作为基础镜像
 FROM openjdk:8-jdk-alpine
+
 # author
 MAINTAINER hs-bd
 

bd-location/src/main/java/com/ruoyi/bd/domain/video/Device.java

@@ -0,0 +1,433 @@
+package com.ruoyi.bd.domain.video;
+
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+/**
+ * 国标设备/平台
+ *
+ * @author lin
+ */
+@ApiModel(value = "国标设备/平台")
+public class Device {
+
+    /**
+     * 设备国标编号
+     */
+    @ApiModelProperty(value = "设备国标编号")
+    private String deviceId;
+
+    /**
+     * 设备名
+     */
+    @ApiModelProperty(value = "名称")
+    private String name;
+
+    /**
+     * 生产厂商
+     */
+    @ApiModelProperty(value = "生产厂商")
+    private String manufacturer;
+
+    /**
+     * 型号
+     */
+    @ApiModelProperty(value = "型号")
+    private String model;
+
+    /**
+     * 固件版本
+     */
+    @ApiModelProperty(value = "固件版本")
+    private String firmware;
+
+    /**
+     * 传输协议
+     * UDP/TCP
+     */
+    @ApiModelProperty(value = "传输协议（UDP/TCP）")
+    private String transport;
+
+    /**
+     * 数据流传输模式
+     * UDP:udp传输
+     * TCP-ACTIVE：tcp主动模式
+     * TCP-PASSIVE：tcp被动模式
+     */
+    @ApiModelProperty(value = "数据流传输模式")
+    private String streamMode;
+
+    /**
+     * wan地址_ip
+     */
+    @ApiModelProperty(value = "IP")
+    private String ip;
+
+    /**
+     * wan地址_port
+     */
+    @ApiModelProperty(value = "端口")
+    private int port;
+
+    /**
+     * wan地址
+     */
+    @ApiModelProperty(value = "wan地址")
+    private String hostAddress;
+
+    /**
+     * 在线
+     */
+    @ApiModelProperty(value = "是否在线，1为在线，0为离线")
+    private int online;
+
+
+    /**
+     * 注册时间
+     */
+    @ApiModelProperty(value = "注册时间")
+    private String registerTime;
+
+
+    /**
+     * 心跳时间
+     */
+    @ApiModelProperty(value = "心跳时间")
+    private String keepaliveTime;
+
+
+    /**
+     * 心跳间隔
+     */
+    @ApiModelProperty(value = "心跳间隔")
+    private int keepaliveIntervalTime;
+
+    /**
+     * 通道个数
+     */
+    @ApiModelProperty(value = "通道个数")
+    private int channelCount;
+
+    /**
+     * 注册有效期
+     */
+    @ApiModelProperty(value = "注册有效期")
+    private int expires;
+
+    /**
+     * 创建时间
+     */
+    @ApiModelProperty(value = "创建时间")
+    private String createTime;
+
+    /**
+     * 更新时间
+     */
+    @ApiModelProperty(value = "更新时间")
+    private String updateTime;
+
+    /**
+     * 设备使用的媒体id, 默认为null
+     */
+    @ApiModelProperty(value = "设备使用的媒体id, 默认为null")
+    private String mediaServerId;
+
+    /**
+     * 字符集, 支持 UTF-8 与 GB2312
+     */
+    @ApiModelProperty(value = "符集, 支持 UTF-8 与 GB2312")
+    private String charset;
+
+    /**
+     * 目录订阅周期，0为不订阅
+     */
+    @ApiModelProperty(value = "目录订阅周期，0为不订阅")
+    private int subscribeCycleForCatalog;
+
+    /**
+     * 移动设备位置订阅周期，0为不订阅
+     */
+    @ApiModelProperty(value = "移动设备位置订阅周期，0为不订阅")
+    private int subscribeCycleForMobilePosition;
+
+    /**
+     * 移动设备位置信息上报时间间隔,单位:秒,默认值5
+     */
+    @ApiModelProperty(value = "移动设备位置信息上报时间间隔,单位:秒,默认值5")
+    private int mobilePositionSubmissionInterval = 5;
+
+    /**
+     * 报警订阅周期，0为不订阅
+     */
+    @ApiModelProperty(value = "报警心跳时间订阅周期，0为不订阅")
+    private int subscribeCycleForAlarm;
+
+    /**
+     * 是否开启ssrc校验，默认关闭，开启可以防止串流
+     */
+    @ApiModelProperty(value = "是否开启ssrc校验，默认关闭，开启可以防止串流")
+    private boolean ssrcCheck = true;
+
+    /**
+     * 地理坐标系， 目前支持 WGS84,GCJ02
+     */
+    @ApiModelProperty(value = "地理坐标系， 目前支持 WGS84,GCJ02")
+    private String geoCoordSys;
+
+    /**
+     * 树类型 国标规定了两种树的展现方式 行政区划：CivilCode 和业务分组:BusinessGroup
+     */
+    @ApiModelProperty(value = "树类型 国标规定了两种树的展现方式 行政区划：CivilCode 和业务分组:BusinessGroup")
+    private String treeType;
+
+    @ApiModelProperty(value = "密码")
+    private String password;
+
+    @ApiModelProperty(value = "收流IP")
+    private String sdpIp;
+
+    @ApiModelProperty(value = "SIP交互IP（设备访问平台的IP）")
+    private String localIp;
+
+
+    public String getDeviceId() {
+        return deviceId;
+    }
+
+    public void setDeviceId(String deviceId) {
+        this.deviceId = deviceId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getManufacturer() {
+        return manufacturer;
+    }
+
+    public void setManufacturer(String manufacturer) {
+        this.manufacturer = manufacturer;
+    }
+
+    public String getModel() {
+        return model;
+    }
+
+    public void setModel(String model) {
+        this.model = model;
+    }
+
+    public String getFirmware() {
+        return firmware;
+    }
+
+    public void setFirmware(String firmware) {
+        this.firmware = firmware;
+    }
+
+    public String getTransport() {
+        return transport;
+    }
+
+    public void setTransport(String transport) {
+        this.transport = transport;
+    }
+
+    public String getStreamMode() {
+        return streamMode;
+    }
+
+    public void setStreamMode(String streamMode) {
+        this.streamMode = streamMode;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public void setIp(String ip) {
+        this.ip = ip;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public void setPort(int port) {
+        this.port = port;
+    }
+
+    public String getHostAddress() {
+        return hostAddress;
+    }
+
+    public void setHostAddress(String hostAddress) {
+        this.hostAddress = hostAddress;
+    }
+
+    public int getOnline() {
+        return online;
+    }
+
+    public void setOnline(int online) {
+        this.online = online;
+    }
+
+    public int getChannelCount() {
+        return channelCount;
+    }
+
+    public void setChannelCount(int channelCount) {
+        this.channelCount = channelCount;
+    }
+
+    public String getRegisterTime() {
+        return registerTime;
+    }
+
+    public void setRegisterTime(String registerTime) {
+        this.registerTime = registerTime;
+    }
+
+    public String getKeepaliveTime() {
+        return keepaliveTime;
+    }
+
+    public void setKeepaliveTime(String keepaliveTime) {
+        this.keepaliveTime = keepaliveTime;
+    }
+
+    public int getExpires() {
+        return expires;
+    }
+
+    public void setExpires(int expires) {
+        this.expires = expires;
+    }
+
+    public String getCreateTime() {
+        return createTime;
+    }
+
+    public void setCreateTime(String createTime) {
+        this.createTime = createTime;
+    }
+
+    public String getUpdateTime() {
+        return updateTime;
+    }
+
+    public void setUpdateTime(String updateTime) {
+        this.updateTime = updateTime;
+    }
+
+    public String getMediaServerId() {
+        return mediaServerId;
+    }
+
+    public void setMediaServerId(String mediaServerId) {
+        this.mediaServerId = mediaServerId;
+    }
+
+    public String getCharset() {
+        return charset;
+    }
+
+    public void setCharset(String charset) {
+        this.charset = charset;
+    }
+
+    public int getSubscribeCycleForCatalog() {
+        return subscribeCycleForCatalog;
+    }
+
+    public void setSubscribeCycleForCatalog(int subscribeCycleForCatalog) {
+        this.subscribeCycleForCatalog = subscribeCycleForCatalog;
+    }
+
+    public int getSubscribeCycleForMobilePosition() {
+        return subscribeCycleForMobilePosition;
+    }
+
+    public void setSubscribeCycleForMobilePosition(int subscribeCycleForMobilePosition) {
+        this.subscribeCycleForMobilePosition = subscribeCycleForMobilePosition;
+    }
+
+    public int getMobilePositionSubmissionInterval() {
+        return mobilePositionSubmissionInterval;
+    }
+
+    public void setMobilePositionSubmissionInterval(int mobilePositionSubmissionInterval) {
+        this.mobilePositionSubmissionInterval = mobilePositionSubmissionInterval;
+    }
+
+    public int getSubscribeCycleForAlarm() {
+        return subscribeCycleForAlarm;
+    }
+
+    public void setSubscribeCycleForAlarm(int subscribeCycleForAlarm) {
+        this.subscribeCycleForAlarm = subscribeCycleForAlarm;
+    }
+
+    public boolean isSsrcCheck() {
+        return ssrcCheck;
+    }
+
+    public void setSsrcCheck(boolean ssrcCheck) {
+        this.ssrcCheck = ssrcCheck;
+    }
+
+    public String getGeoCoordSys() {
+        return geoCoordSys;
+    }
+
+    public void setGeoCoordSys(String geoCoordSys) {
+        this.geoCoordSys = geoCoordSys;
+    }
+
+    public String getTreeType() {
+        return treeType;
+    }
+
+    public void setTreeType(String treeType) {
+        this.treeType = treeType;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public String getSdpIp() {
+        return sdpIp;
+    }
+
+    public void setSdpIp(String sdpIp) {
+        this.sdpIp = sdpIp;
+    }
+
+    public String getLocalIp() {
+        return localIp;
+    }
+
+    public void setLocalIp(String localIp) {
+        this.localIp = localIp;
+    }
+
+    public int getKeepaliveIntervalTime() {
+        return keepaliveIntervalTime;
+    }
+
+    public void setKeepaliveIntervalTime(int keepaliveIntervalTime) {
+        this.keepaliveIntervalTime = keepaliveIntervalTime;
+    }
+}

bd-location/src/main/java/com/ruoyi/bd/domain/video/DeviceChannel.java

@@ -0,0 +1,578 @@
+package com.ruoyi.bd.domain.video;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+@ApiModel(value = "通道信息")
+public class DeviceChannel {
+
+
+    /**
+     * 数据库自增ID
+     */
+    @ApiModelProperty(value ="数据库自增ID")
+    private int id;
+
+    /**
+     * 通道国标编号
+     */
+    @ApiModelProperty(value ="通道国标编号")
+    private String channelId;
+
+    /**
+     * 设备国标编号
+     */
+    @ApiModelProperty(value ="设备国标编号")
+    private String deviceId;
+
+    /**
+     * 通道名
+     */
+    @ApiModelProperty(value ="名称")
+    private String name;
+
+    /**
+     * 生产厂商
+     */
+    @ApiModelProperty(value ="生产厂商")
+    private String manufacture;
+
+    /**
+     * 型号
+     */
+    @ApiModelProperty(value ="型号")
+    private String model;
+
+    /**
+     * 设备归属
+     */
+    @ApiModelProperty(value ="设备归属")
+    private String owner;
+
+    /**
+     * 行政区域
+     */
+    @ApiModelProperty(value ="行政区域")
+    private String civilCode;
+
+    /**
+     * 警区
+     */
+    @ApiModelProperty(value ="警区")
+    private String block;
+
+    /**
+     * 安装地址
+     */
+    @ApiModelProperty(value ="安装地址")
+    private String address;
+
+    /**
+     * 是否有子设备 1有, 0没有
+     */
+    @ApiModelProperty(value ="是否有子设备 1有, 0没有")
+    private int parental;
+
+    /**
+     * 父级id
+     */
+    @ApiModelProperty(value ="父级id")
+    private String parentId;
+
+    /**
+     * 信令安全模式  缺省为0; 0:不采用; 2: S/MIME签名方式; 3: S/ MIME加密签名同时采用方式; 4:数字摘要方式
+     */
+    @ApiModelProperty(value ="信令安全模式  缺省为0; 0:不采用; 2: S/MIME签名方式; 3: S/ MIME加密签名同时采用方式; 4:数字摘要方式")
+    private int safetyWay;
+
+    /**
+     * 注册方式 缺省为1;1:符合IETFRFC3261标准的认证注册模 式; 2:基于口令的双向认证注册模式; 3:基于数字证书的双向认证注册模式
+     */
+    @ApiModelProperty(value ="注册方式 缺省为1;1:符合IETFRFC3261标准的认证注册模 式; 2:基于口令的双向认证注册模式; 3:基于数字证书的双向认证注册模式")
+    private int registerWay;
+
+    /**
+     * 证书序列号
+     */
+    @ApiModelProperty(value ="证书序列号")
+    private String certNum;
+
+    /**
+     * 证书有效标识 缺省为0;证书有效标识:0:无效1: 有效
+     */
+    @ApiModelProperty(value ="证书有效标识 缺省为0;证书有效标识:0:无效1: 有效")
+    private int certifiable;
+
+    /**
+     * 证书无效原因码
+     */
+    @ApiModelProperty(value ="证书无效原因码")
+    private int errCode;
+
+    /**
+     * 证书终止有效期
+     */
+    @ApiModelProperty(value ="证书终止有效期")
+    private String endTime;
+
+    /**
+     * 保密属性 缺省为0; 0:不涉密, 1:涉密
+     */
+    @ApiModelProperty(value ="保密属性 缺省为0; 0:不涉密, 1:涉密")
+    private String secrecy;
+
+    /**
+     * IP地址
+     */
+    @ApiModelProperty(value ="IP地址")
+    private String ipAddress;
+
+    /**
+     * 端口号
+     */
+    @ApiModelProperty(value ="端口号")
+    private int port;
+
+    /**
+     * 密码
+     */
+    @ApiModelProperty(value ="密码")
+    private String password;
+
+    /**
+     * 云台类型
+     */
+    @ApiModelProperty(value ="云台类型")
+    private int PTZType;
+
+    /**
+     * 云台类型描述字符串
+     */
+    @ApiModelProperty(value ="云台类型描述字符串")
+    private String PTZTypeText;
+
+    /**
+     * 创建时间
+     */
+    @ApiModelProperty(value ="创建时间")
+    private String createTime;
+
+    /**
+     * 更新时间
+     */
+    @ApiModelProperty(value ="更新时间")
+    private String updateTime;
+
+    /**
+     * 在线/离线
+     * 1在线,0离线
+     * 默认在线
+     * 信令:
+     * <Status>ON</Status>
+     * <Status>OFF</Status>
+     * 遇到过NVR下的IPC下发信令可以推流， 但是 Status 响应 OFF
+     */
+    @ApiModelProperty(value ="在线/离线， 1在线,0离线")
+    private int status;
+
+    /**
+     * 经度
+     */
+    @ApiModelProperty(value ="经度")
+    private double longitude;
+
+    /**
+     * 纬度
+     */
+    @ApiModelProperty(value ="纬度")
+    private double latitude;
+
+    /**
+     * 经度 GCJ02
+     */
+    @ApiModelProperty(value ="GCJ02坐标系经度")
+    private double longitudeGcj02;
+
+    /**
+     * 纬度 GCJ02
+     */
+    @ApiModelProperty(value ="GCJ02坐标系纬度")
+    private double latitudeGcj02;
+
+    /**
+     * 经度 WGS84
+     */
+    @ApiModelProperty(value ="WGS84坐标系经度")
+    private double longitudeWgs84;
+
+    /**
+     * 纬度 WGS84
+     */
+    @ApiModelProperty(value ="WGS84坐标系纬度")
+    private double latitudeWgs84;
+
+    /**
+     * 子设备数
+     */
+    @ApiModelProperty(value ="子设备数")
+    private int subCount;
+
+    /**
+     * 流唯一编号，存在表示正在直播
+     */
+    @ApiModelProperty(value ="流唯一编号，存在表示正在直播")
+    private String  streamId;
+
+    /**
+     *  是否含有音频
+     */
+    @ApiModelProperty(value ="是否含有音频")
+    private boolean hasAudio;
+
+    /**
+     * 标记通道的类型，0->国标通道 1->直播流通道 2->业务分组/虚拟组织/行政区划
+     */
+    @ApiModelProperty(value ="标记通道的类型，0->国标通道 1->直播流通道 2->业务分组/虚拟组织/行政区划")
+    private int channelType;
+
+    /**
+     * 业务分组
+     */
+    @ApiModelProperty(value ="业务分组")
+    private String businessGroupId;
+
+    /**
+     * GPS的更新时间
+     */
+    @ApiModelProperty(value ="GPS的更新时间")
+    private String gpsTime;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getDeviceId() {
+        return deviceId;
+    }
+
+    public void setDeviceId(String deviceId) {
+        this.deviceId = deviceId;
+    }
+
+    public void setPTZType(int PTZType) {
+        this.PTZType = PTZType;
+        switch (PTZType) {
+            case 0:
+                this.PTZTypeText = "未知";
+                break;
+            case 1:
+                this.PTZTypeText = "球机";
+                break;
+            case 2:
+                this.PTZTypeText = "半球";
+                break;
+            case 3:
+                this.PTZTypeText = "固定枪机";
+                break;
+            case 4:
+                this.PTZTypeText = "遥控枪机";
+                break;
+        }
+    }
+
+    public String getChannelId() {
+        return channelId;
+    }
+
+    public void setChannelId(String channelId) {
+        this.channelId = channelId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getManufacture() {
+        return manufacture;
+    }
+
+    public void setManufacture(String manufacture) {
+        this.manufacture = manufacture;
+    }
+
+    public String getModel() {
+        return model;
+    }
+
+    public void setModel(String model) {
+        this.model = model;
+    }
+
+    public String getOwner() {
+        return owner;
+    }
+
+    public void setOwner(String owner) {
+        this.owner = owner;
+    }
+
+    public String getCivilCode() {
+        return civilCode;
+    }
+
+    public void setCivilCode(String civilCode) {
+        this.civilCode = civilCode;
+    }
+
+    public String getBlock() {
+        return block;
+    }
+
+    public void setBlock(String block) {
+        this.block = block;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    public int getParental() {
+        return parental;
+    }
+
+    public void setParental(int parental) {
+        this.parental = parental;
+    }
+
+    public String getParentId() {
+        return parentId;
+    }
+
+    public void setParentId(String parentId) {
+        this.parentId = parentId;
+    }
+
+    public int getSafetyWay() {
+        return safetyWay;
+    }
+
+    public void setSafetyWay(int safetyWay) {
+        this.safetyWay = safetyWay;
+    }
+
+    public int getRegisterWay() {
+        return registerWay;
+    }
+
+    public void setRegisterWay(int registerWay) {
+        this.registerWay = registerWay;
+    }
+
+    public String getCertNum() {
+        return certNum;
+    }
+
+    public void setCertNum(String certNum) {
+        this.certNum = certNum;
+    }
+
+    public int getCertifiable() {
+        return certifiable;
+    }
+
+    public void setCertifiable(int certifiable) {
+        this.certifiable = certifiable;
+    }
+
+    public int getErrCode() {
+        return errCode;
+    }
+
+    public void setErrCode(int errCode) {
+        this.errCode = errCode;
+    }
+
+    public String getEndTime() {
+        return endTime;
+    }
+
+    public void setEndTime(String endTime) {
+        this.endTime = endTime;
+    }
+
+    public String getSecrecy() {
+        return secrecy;
+    }
+
+    public void setSecrecy(String secrecy) {
+        this.secrecy = secrecy;
+    }
+
+    public String getIpAddress() {
+        return ipAddress;
+    }
+
+    public void setIpAddress(String ipAddress) {
+        this.ipAddress = ipAddress;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public void setPort(int port) {
+        this.port = port;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public int getPTZType() {
+        return PTZType;
+    }
+
+    public String getPTZTypeText() {
+        return PTZTypeText;
+    }
+
+    public void setPTZTypeText(String PTZTypeText) {
+        this.PTZTypeText = PTZTypeText;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    public void setStatus(int status) {
+        this.status = status;
+    }
+
+    public double getLongitude() {
+        return longitude;
+    }
+
+    public void setLongitude(double longitude) {
+        this.longitude = longitude;
+    }
+
+    public double getLatitude() {
+        return latitude;
+    }
+
+    public void setLatitude(double latitude) {
+        this.latitude = latitude;
+    }
+
+    public double getLongitudeGcj02() {
+        return longitudeGcj02;
+    }
+
+    public void setLongitudeGcj02(double longitudeGcj02) {
+        this.longitudeGcj02 = longitudeGcj02;
+    }
+
+    public double getLatitudeGcj02() {
+        return latitudeGcj02;
+    }
+
+    public void setLatitudeGcj02(double latitudeGcj02) {
+        this.latitudeGcj02 = latitudeGcj02;
+    }
+
+    public double getLongitudeWgs84() {
+        return longitudeWgs84;
+    }
+
+    public void setLongitudeWgs84(double longitudeWgs84) {
+        this.longitudeWgs84 = longitudeWgs84;
+    }
+
+    public double getLatitudeWgs84() {
+        return latitudeWgs84;
+    }
+
+    public void setLatitudeWgs84(double latitudeWgs84) {
+        this.latitudeWgs84 = latitudeWgs84;
+    }
+
+    public int getSubCount() {
+        return subCount;
+    }
+
+    public void setSubCount(int subCount) {
+        this.subCount = subCount;
+    }
+
+    public boolean isHasAudio() {
+        return hasAudio;
+    }
+
+    public void setHasAudio(boolean hasAudio) {
+        this.hasAudio = hasAudio;
+    }
+
+    public String getStreamId() {
+        return streamId;
+    }
+
+    public void setStreamId(String streamId) {
+        this.streamId = streamId;
+    }
+
+    public String getCreateTime() {
+        return createTime;
+    }
+
+    public void setCreateTime(String createTime) {
+        this.createTime = createTime;
+    }
+
+    public String getUpdateTime() {
+        return updateTime;
+    }
+
+    public void setUpdateTime(String updateTime) {
+        this.updateTime = updateTime;
+    }
+
+    public int getChannelType() {
+        return channelType;
+    }
+
+    public void setChannelType(int channelType) {
+        this.channelType = channelType;
+    }
+
+    public String getBusinessGroupId() {
+        return businessGroupId;
+    }
+
+    public void setBusinessGroupId(String businessGroupId) {
+        this.businessGroupId = businessGroupId;
+    }
+
+    public String getGpsTime() {
+        return gpsTime;
+    }
+
+    public void setGpsTime(String gpsTime) {
+        this.gpsTime = gpsTime;
+    }
+}

bd-location/src/main/java/com/ruoyi/bd/domain/video/PlayConvertObj.java

@@ -0,0 +1,37 @@
+package com.ruoyi.bd.domain.video;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import org.springframework.data.redis.connection.stream.StreamInfo;
+
+/**
+ * description
+ *
+ * @author cy
+ * @date 2023/2/7 17:55
+ */
+@ApiModel("视频转码")
+public class PlayConvertObj {
+
+    @ApiModelProperty("")
+    private String key;
+
+    @ApiModelProperty("流媒体信息")
+    private StreamInfo streamInfo;
+
+    public String getKey() {
+        return key;
+    }
+
+    public void setKey(String key) {
+        this.key = key;
+    }
+
+    public StreamInfo getStreamInfo() {
+        return streamInfo;
+    }
+
+    public void setStreamInfo(StreamInfo streamInfo) {
+        this.streamInfo = streamInfo;
+    }
+}

bd-location/src/main/java/com/ruoyi/bd/domain/video/PlayStopObj.java

@@ -0,0 +1,36 @@
+package com.ruoyi.bd.domain.video;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+/**
+ * description
+ *
+ * @author cy
+ * @date 2023/2/7 17:37
+ */
+@ApiModel(value = "停止播放")
+public class PlayStopObj {
+
+    @ApiModelProperty("设备Id")
+    private String deviceId;
+
+    @ApiModelProperty("通道Id")
+    private String channelId;
+
+    public String getDeviceId() {
+        return deviceId;
+    }
+
+    public void setDeviceId(String deviceId) {
+        this.deviceId = deviceId;
+    }
+
+    public String getChannelId() {
+        return channelId;
+    }
+
+    public void setChannelId(String channelId) {
+        this.channelId = channelId;
+    }
+}

bd-location/src/main/java/com/ruoyi/bd/domain/video/StreamContent.java

@@ -0,0 +1,310 @@
+package com.ruoyi.bd.domain.video;
+
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+@ApiModel(value = "流媒体地址")
+public class StreamContent {
+
+    @ApiModelProperty(value = "应用名")
+    private String app;
+    @ApiModelProperty(value = "流ID")
+    private String stream;
+    @ApiModelProperty(value = "IP")
+    private String ip;
+    @ApiModelProperty(value = "HTTP-FLV流地址")
+    private String flv;
+    @ApiModelProperty(value = "HTTPS-FLV流地址")
+    private String https_flv;
+    @ApiModelProperty(value = "Websocket-FLV流地址")
+    private String ws_flv;
+    @ApiModelProperty(value = "Websockets-FLV流地址")
+    private String wss_flv;
+    @ApiModelProperty(value = "HTTP-FMP4流地址")
+    private String fmp4;
+    @ApiModelProperty(value = "HTTPS-FMP4流地址")
+    private String https_fmp4;
+    @ApiModelProperty(value = "Websocket-FMP4流地址")
+    private String ws_fmp4;
+    @ApiModelProperty(value = "Websockets-FMP4流地址")
+    private String wss_fmp4;
+    @ApiModelProperty(value = "HLS流地址")
+    private String hls;
+    @ApiModelProperty(value = "HTTPS-HLS流地址")
+    private String https_hls;
+    @ApiModelProperty(value = "Websocket-HLS流地址")
+    private String ws_hls;
+    @ApiModelProperty(value = "Websockets-HLS流地址")
+    private String wss_hls;
+    @ApiModelProperty(value = "HTTP-TS流地址")
+    private String ts;
+    @ApiModelProperty(value = "HTTPS-TS流地址")
+    private String https_ts;
+    @ApiModelProperty(value = "Websocket-TS流地址")
+    private String ws_ts;
+    @ApiModelProperty(value = "Websockets-TS流地址")
+    private String wss_ts;
+    @ApiModelProperty(value = "RTMP流地址")
+    private String rtmp;
+    @ApiModelProperty(value = "RTMPS流地址")
+    private String rtmps;
+    @ApiModelProperty(value = "RTSP流地址")
+    private String rtsp;
+    @ApiModelProperty(value = "RTSPS流地址")
+    private String rtsps;
+    @ApiModelProperty(value = "RTC流地址")
+    private String rtc;
+    @ApiModelProperty(value = "RTCS流地址")
+    private String rtcs;
+    @ApiModelProperty(value = "流媒体ID")
+    private String mediaServerId;
+    @ApiModelProperty(value = "流编码信息")
+    private Object tracks;
+    @ApiModelProperty(value = "开始时间")
+    private String startTime;
+    @ApiModelProperty(value = "结束时间")
+    private String endTime;
+    @ApiModelProperty(value = "进度（录像下载使用）")
+    private double progress;
+
+    public String getApp() {
+        return app;
+    }
+
+    public void setApp(String app) {
+        this.app = app;
+    }
+
+    public String getStream() {
+        return stream;
+    }
+
+    public void setStream(String stream) {
+        this.stream = stream;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public void setIp(String ip) {
+        this.ip = ip;
+    }
+
+    public String getFlv() {
+        return flv;
+    }
+
+    public void setFlv(String flv) {
+        this.flv = flv;
+    }
+
+    public String getHttps_flv() {
+        return https_flv;
+    }
+
+    public void setHttps_flv(String https_flv) {
+        this.https_flv = https_flv;
+    }
+
+    public String getWs_flv() {
+        return ws_flv;
+    }
+
+    public void setWs_flv(String ws_flv) {
+        this.ws_flv = ws_flv;
+    }
+
+    public String getWss_flv() {
+        return wss_flv;
+    }
+
+    public void setWss_flv(String wss_flv) {
+        this.wss_flv = wss_flv;
+    }
+
+    public String getFmp4() {
+        return fmp4;
+    }
+
+    public void setFmp4(String fmp4) {
+        this.fmp4 = fmp4;
+    }
+
+    public String getHttps_fmp4() {
+        return https_fmp4;
+    }
+
+    public void setHttps_fmp4(String https_fmp4) {
+        this.https_fmp4 = https_fmp4;
+    }
+
+    public String getWs_fmp4() {
+        return ws_fmp4;
+    }
+
+    public void setWs_fmp4(String ws_fmp4) {
+        this.ws_fmp4 = ws_fmp4;
+    }
+
+    public String getWss_fmp4() {
+        return wss_fmp4;
+    }
+
+    public void setWss_fmp4(String wss_fmp4) {
+        this.wss_fmp4 = wss_fmp4;
+    }
+
+    public String getHls() {
+        return hls;
+    }
+
+    public void setHls(String hls) {
+        this.hls = hls;
+    }
+
+    public String getHttps_hls() {
+        return https_hls;
+    }
+
+    public void setHttps_hls(String https_hls) {
+        this.https_hls = https_hls;
+    }
+
+    public String getWs_hls() {
+        return ws_hls;
+    }
+
+    public void setWs_hls(String ws_hls) {
+        this.ws_hls = ws_hls;
+    }
+
+    public String getWss_hls() {
+        return wss_hls;
+    }
+
+    public void setWss_hls(String wss_hls) {
+        this.wss_hls = wss_hls;
+    }
+
+    public String getTs() {
+        return ts;
+    }
+
+    public void setTs(String ts) {
+        this.ts = ts;
+    }
+
+    public String getHttps_ts() {
+        return https_ts;
+    }
+
+    public void setHttps_ts(String https_ts) {
+        this.https_ts = https_ts;
+    }
+
+    public String getWs_ts() {
+        return ws_ts;
+    }
+
+    public void setWs_ts(String ws_ts) {
+        this.ws_ts = ws_ts;
+    }
+
+    public String getWss_ts() {
+        return wss_ts;
+    }
+
+    public void setWss_ts(String wss_ts) {
+        this.wss_ts = wss_ts;
+    }
+
+    public String getRtmp() {
+        return rtmp;
+    }
+
+    public void setRtmp(String rtmp) {
+        this.rtmp = rtmp;
+    }
+
+    public String getRtmps() {
+        return rtmps;
+    }
+
+    public void setRtmps(String rtmps) {
+        this.rtmps = rtmps;
+    }
+
+    public String getRtsp() {
+        return rtsp;
+    }
+
+    public void setRtsp(String rtsp) {
+        this.rtsp = rtsp;
+    }
+
+    public String getRtsps() {
+        return rtsps;
+    }
+
+    public void setRtsps(String rtsps) {
+        this.rtsps = rtsps;
+    }
+
+    public String getRtc() {
+        return rtc;
+    }
+
+    public void setRtc(String rtc) {
+        this.rtc = rtc;
+    }
+
+    public String getRtcs() {
+        return rtcs;
+    }
+
+    public void setRtcs(String rtcs) {
+        this.rtcs = rtcs;
+    }
+
+    public String getMediaServerId() {
+        return mediaServerId;
+    }
+
+    public void setMediaServerId(String mediaServerId) {
+        this.mediaServerId = mediaServerId;
+    }
+
+    public Object getTracks() {
+        return tracks;
+    }
+
+    public void setTracks(Object tracks) {
+        this.tracks = tracks;
+    }
+
+    public String getStartTime() {
+        return startTime;
+    }
+
+    public void setStartTime(String startTime) {
+        this.startTime = startTime;
+    }
+
+    public String getEndTime() {
+        return endTime;
+    }
+
+    public void setEndTime(String endTime) {
+        this.endTime = endTime;
+    }
+
+    public double getProgress() {
+        return progress;
+    }
+
+    public void setProgress(double progress) {
+        this.progress = progress;
+    }
+}

bd-location/src/main/java/com/ruoyi/bd/service/impl/FFMpegService.java

@@ -0,0 +1,17 @@
+package com.ruoyi.bd.service.impl;
+
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+
+@Service
+public class FFMpegService {
+
+    public void writeToRtsp(String inputFilePath) throws IOException, InterruptedException {
+        ProcessBuilder processBuilder = new ProcessBuilder(
+                "ffmpeg", "-i", inputFilePath, "-c:a", "copy", "-f", "rtsp", "rtsp://36.152.142.44:40007/broadcast/34020000001320000103_34020000001320000001?sign=41db35390ddad33f83944f44b8b75ded"
+        );
+        Process process = processBuilder.start();
+        process.waitFor();
+    }
+}

bd-location/src/main/java/com/ruoyi/bd/service/rpc/DeviceQueryService.java

@@ -0,0 +1,126 @@
+package com.ruoyi.bd.service.rpc;
+
+import com.alibaba.fastjson2.JSONObject;
+import com.dtflys.forest.annotation.*;
+import com.dtflys.forest.callback.OnError;
+import com.dtflys.forest.callback.OnSuccess;
+import com.dtflys.forest.http.ForestResponse;
+import com.github.pagehelper.PageInfo;
+import com.ruoyi.bd.domain.video.Device;
+import com.ruoyi.common.response.AppResponse;
+
+import java.io.InputStream;
+
+/**
+ * description wvp接口对接
+ *
+ * @author cy
+ * @date 2023/1/9 10:24
+ */
+@BaseRequest(baseURL = "${baseHost}")
+public interface DeviceQueryService {
+
+    @Get(url = "{queryPath}/devices?page={0}&count={1}")
+    ForestResponse<AppResponse<PageInfo<Device>>> queryVideoDeviceList(int page, int size, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Get(url = "{queryPath}/devices/{deviceId}/channels")
+    ForestResponse<AppResponse<Object>> channels(@Var("deviceId") String deviceId, @Query("page") int page, @Query("count") int count, @Query("query") String query,
+                                                 @Query("online") Boolean online, @Query("channelType") Boolean channelType,
+                                                 @Query("catalogUnderDevice") Boolean catalogUnderDevice,
+                                                 @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Get(url = "{queryPath}/devices/{deviceId}")
+    ForestResponse<AppResponse> queryVideoDevice(@Var("deviceId") String deviceId, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Get(url = "{queryPath}/sub_channels/{deviceId}/{channelId}/channels")
+    ForestResponse<AppResponse> querySubChannels(@Var("deviceId") String deviceId, @Var("channelId") String channelId, @Query("page") int page, @Query("count") int count, @Query("query") String query,
+                                                 @Query("online") Boolean online, @Query("channelType") Boolean channelType,
+                                                 @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Get(url = "{queryPath}/tree/{deviceId}")
+    ForestResponse<AppResponse> queryVideoDeviceTree(@Var("deviceId") String deviceId, @Query("parentId") String parentId,
+                                                     @Query("onlyCatalog") Boolean onlyCatalog, @Query("page") int page, @Query("count") int count,
+                                                     @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Get(url = "{queryPath}/tree/channel/{deviceId}")
+    ForestResponse<AppResponse> getChannelInTreeNode(@Var("deviceId") String deviceId, @Query("parentId") String parentId, @Query("page") int page, @Query("count") int count,
+                                                     @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Post(url = "{queryPath}/channel/update/{deviceId}")
+    ForestResponse<AppResponse> updateChannel(@Var("deviceId") String deviceId, @Body JSONObject obj, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    /**
+     * 添加设备信息
+     *
+     * @param device 设备信息
+     * @return
+     */
+    @Post(url = "{queryPath}/device/add/")
+    ForestResponse<AppResponse> addDevice(@Body JSONObject device, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    /**
+     * 更新设备信息
+     *
+     * @param device 设备信息
+     * @return
+     */
+    @Post(url = "{queryPath}/device/update/")
+    ForestResponse<AppResponse> updateDevice(@Body JSONObject device, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    /**
+     * 修改数据流传输模式
+     *
+     * @param deviceId   设备id
+     * @param streamMode 数据流传输模式
+     * @return
+     */
+    @Post(url = "{queryPath}/transport/{deviceId}/{streamMode}")
+    ForestResponse<AppResponse> updateTransport(@Var("deviceId") String deviceId, @Var("streamMode") String streamMode, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+
+    /**
+     * 移除设备
+     *
+     * @param deviceId 设备id
+     * @return
+     */
+    @Delete(url = "{queryPath}/devices/{deviceId}/delete")
+    ForestResponse<AppResponse> delete(@Var("deviceId") String deviceId, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    /**
+     * 同步设备通道
+     *
+     * @param deviceId 设备id
+     * @return
+     */
+    @Get(url = "{queryPath}/devices/{deviceId}/sync")
+    ForestResponse<AppResponse> devicesSync(@Var("deviceId") String deviceId, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    /**
+     * 获取通道同步进度
+     *
+     * @param deviceId 设备id
+     * @return
+     */
+    @Get(url = "{queryPath}/{deviceId}/sync_status")
+    ForestResponse<AppResponse> getSyncStatus(@Var("deviceId") String deviceId, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+
+    /**
+     * 请求截图
+     *
+     * @param deviceId 设备id
+     * @return
+     */
+    @Get(url = "{queryPath}/snap/{deviceId}/{channelId}")
+    InputStream getSnap(@Var("deviceId") String deviceId, @Var("channelId") String channelId, @Header("access-token") String accessToken, OnSuccess<InputStream> onSuccess, OnError onError);
+
+    /**
+     * 编码信息
+     *
+     * @return
+     */
+    @Get(url = "/zlm/{mediaServerId}/index/api/getMediaInfo?vhost=__defaultVhost__&schema=rtsp&app={app}&stream={streamId}")
+    ForestResponse<JSONObject> getMediaInfo(@Var("mediaServerId") String mediaServerId, @Var("app") String app, @Var("streamId") String streamId, @Header("access-token") String accessToken, OnSuccess<JSONObject> onSuccess, OnError onError);
+
+}

bd-location/src/main/java/com/ruoyi/bd/service/rpc/PlayService.java

@@ -0,0 +1,36 @@
+package com.ruoyi.bd.service.rpc;
+
+import com.dtflys.forest.annotation.*;
+import com.dtflys.forest.callback.OnError;
+import com.dtflys.forest.callback.OnSuccess;
+import com.dtflys.forest.http.ForestResponse;
+import com.ruoyi.common.response.AppResponse;
+
+/**
+ * description
+ *
+ * @author cy
+ * @date 2023/1/11 10:33
+ */
+@BaseRequest(baseURL = "${baseHost}")
+public interface PlayService {
+
+    @Get(url = "{playPath}/start/{deviceId}/{channelId}")
+    ForestResponse<AppResponse> play(@Var("deviceId") String deviceId, @Var("channelId") String channelId, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Get(url = "{playPath}/stop/{deviceId}/{channelId}")
+    ForestResponse<AppResponse> playStop(@Var("deviceId") String deviceId, @Var("channelId") String channelId, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Post(url = "{playPath}/convert/{streamId}")
+    ForestResponse<AppResponse> playConvert(@Var("streamId") String streamId, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Post(url = "{playPath}/convertStop/{key}")
+    ForestResponse<AppResponse> playConvertStop(@Var("key") String key, @Query("mediaServerId") String mediaServerId, @Header("access-token") String accessToken, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Get(url = "{playPath}/broadcast/{deviceId}/{channelId}")
+    ForestResponse<AppResponse> broadcast(@Var("deviceId") String deviceId, @Var("channelId") String channelId, @Header("access-token") String accessToken,@Query("timeout") String timeout, @Query("broadcastMode") String broadcastMode, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+    @Get(url = "{playPath}/broadcast/stop/{deviceId}/{channelId}")
+    ForestResponse<AppResponse> broadcaststop(@Var("deviceId") String deviceId, @Var("channelId") String channelId, @Header("access-token") String accessToken,@Query("timeout") String timeout, @Query("broadcastMode") String broadcastMode, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+}

bd-location/src/main/java/com/ruoyi/bd/service/rpc/WvpUserService.java

@@ -0,0 +1,31 @@
+package com.ruoyi.bd.service.rpc;
+
+import com.dtflys.forest.annotation.BaseRequest;
+import com.dtflys.forest.annotation.Get;
+import com.dtflys.forest.callback.OnError;
+import com.dtflys.forest.callback.OnSaveCookie;
+import com.dtflys.forest.callback.OnSuccess;
+import com.dtflys.forest.http.ForestResponse;
+import com.ruoyi.common.response.AppResponse;
+
+/**
+ * description
+ *
+ * @author cy
+ * @date 2023/1/11 10:48
+ */
+@BaseRequest(baseURL = "${baseHost}")
+public interface WvpUserService {
+
+    /**
+     * description wvp 登录认证接口
+     *
+     * @param: description
+     * @return: com.hs.aiot.common.response.AppResponse
+     * @author cy
+     * @date 2023/1/9 10:34
+     */
+    @Get(url = "/api/user/login?username=admin&password=c8f436bc8ab351315f37ee7694808934")
+    ForestResponse<AppResponse> wvpLogin(OnSaveCookie onSaveCookie, OnSuccess<AppResponse> onSuccess, OnError onError);
+
+}

bd-location/src/main/java/com/ruoyi/bd/service/video/WvpLogin.java

@@ -0,0 +1,53 @@
+package com.ruoyi.bd.service.video;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONObject;
+import com.dtflys.forest.http.ForestCookie;
+import com.ruoyi.bd.service.rpc.WvpUserService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * description
+ *
+ * @author cy
+ * @date 2023/1/11 10:46
+ */
+@Service
+public class WvpLogin {
+    private static final Logger log = LoggerFactory.getLogger(WvpLogin.class);
+    @Resource
+    WvpUserService userService;
+
+    private AtomicReference<ForestCookie> cookieAtomic = new AtomicReference<>(null);
+
+    private String accessToken = null;
+
+    public String getToken() {
+        if (this.accessToken == null) {
+            wvpLogin();
+        }
+        return accessToken;
+    }
+
+    public void wvpLogin() {
+        userService.wvpLogin((request, cookies) -> {
+                    // 将服务端传来的Cookie放入cookieAtomic
+                    log.info("cookies:{}", cookies);
+                    //cookieAtomic.set(cookies.allCookies().get(0));
+                }, (resText, request, response) -> {
+                    // 成功响应回调
+                    log.info("wvp login success:{}", resText);
+                    JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(resText.getData()));
+                    accessToken = jsonObject.getString("accessToken");
+                },
+                (ex, request, response) -> {
+                    // 异常回调
+                    log.error("wvp login failed:{}", response.getContent());
+                });
+    }
+}

bd-location/src/main/java/com/ruoyi/bd/service/video/WvpService.java

@@ -0,0 +1,121 @@
+package com.ruoyi.bd.service.video;
+
+/**
+ * description
+ *
+ * @author cy
+ * @date 2023/2/8 17:55
+ */
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.TypeReference;
+import com.github.pagehelper.PageInfo;
+import com.ruoyi.bd.domain.video.DeviceChannel;
+import com.ruoyi.bd.domain.video.StreamContent;
+import com.ruoyi.bd.service.rpc.DeviceQueryService;
+import com.ruoyi.bd.service.rpc.PlayService;
+import com.ruoyi.common.response.AppResponse;
+import com.ruoyi.common.utils.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
+@Service
+public class WvpService {
+
+    private static final Logger log = LoggerFactory.getLogger(WvpService.class);
+    @Resource
+    DeviceQueryService deviceQueryService;
+
+    @Resource
+    PlayService playService;
+
+    @Resource
+    WvpLogin wvpLogin;
+
+    public static CountDownLatch countDownLatch = new CountDownLatch(1);
+
+    public AppResponse<Object> channels(String deviceId, int page, int count,
+                                        String query,
+                                        Boolean online,
+                                        Boolean channelType,
+                                        Boolean catalogUnderDevice) {
+        countDownLatch = new CountDownLatch(1);
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        deviceQueryService.channels(deviceId, page, count, query, online, channelType, catalogUnderDevice, wvpLogin.getToken(), (resText, request, response) -> {
+                    // 成功响应回调
+                    appResponse.set(resText);
+                },
+                (ex, request, response) -> {
+                    if (response.getStatusCode() == 401) {
+                        wvpLogin.wvpLogin();
+                        appResponse.set(channels(deviceId, page, count, query, online, channelType, catalogUnderDevice));
+                    } else {
+                        // 异常回调
+                        appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+                    }
+                });
+        countDownLatch.countDown();
+        return appResponse.get();
+    }
+
+    public AppResponse<StreamContent> play(String deviceId, String channelId) {
+        countDownLatch = new CountDownLatch(1);
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        playService.play(deviceId, channelId, wvpLogin.getToken(), (resText, request, response) -> {
+                    // 成功响应回调
+                    appResponse.set(resText);
+                },
+                (ex, request, response) -> {
+                    if (response.getStatusCode() == 401) {
+                        wvpLogin.wvpLogin();
+                        appResponse.set(play(deviceId, channelId));
+                    } else {
+                        // 异常回调
+                        appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+                    }
+                });
+        countDownLatch.countDown();
+        return appResponse.get();
+    }
+
+    public String getChannelId(String deviceId) {
+        //获取通道id列表
+        AppResponse response = channels(deviceId, 1, 15, null, null, null, null);
+        try {
+            WvpService.countDownLatch.await();
+        } catch (InterruptedException e) {
+            log.error("count down latch await {}", e);
+            Thread.currentThread().interrupt();
+        }
+        if (null != response.getData()) {
+            PageInfo<DeviceChannel> deviceChannelPageInfo = JSON.parseObject(JSON.toJSONString(response.getData()), new TypeReference<PageInfo<DeviceChannel>>() {
+            });
+            List<DeviceChannel> list = deviceChannelPageInfo.getList();
+            if (!list.isEmpty()) {
+                return list.get(0).getChannelId();
+            }
+        }
+        return null;
+    }
+
+    public StreamContent getStreamContent(String deviceId, String channelId) {
+        if (!StringUtils.isEmpty(channelId)) {
+            AppResponse playResponse = play(deviceId, channelId);
+            try {
+                WvpService.countDownLatch.await();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+                Thread.currentThread().interrupt();
+            }
+            StreamContent streamContent = JSON.parseObject(JSON.toJSONString(playResponse.getData()), StreamContent.class);
+            return streamContent;
+        }
+        return null;
+    }
+}

bd-location/src/main/java/com/ruoyi/bd/socket/FenceVioEvtSocketServer.java

@@ -19,7 +19,6 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 
 @ServerEndpoint("/ws/evt/{device}")
-@CrossOrigin(origins = "*")
 @Component
 public class FenceVioEvtSocketServer {
     private static final Logger logger = LoggerFactory.getLogger(FenceVioEvtSocketServer.class);

bd-location/src/main/java/com/ruoyi/bd/socket/cfg/WebSocketConfig.java

@@ -0,0 +1,41 @@
+package com.ruoyi.bd.socket.cfg;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
+import org.springframework.web.socket.config.annotation.*;
+import org.springframework.web.socket.server.standard.ServerEndpointExporter;
+
+@Configuration
+@EnableWebSocket
+@EnableWebSocketMessageBroker
+public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
+
+    /**
+     * 作用：注册STOMP协议的节点（端点），并指定映射的URL。
+     * 将“/ws/websocket”注册为端点，客户端订阅消息或发送消息到目的地前要连接该端点
+     * 添加这个Endpoint，这样在网页中就可以通过websocket连接上服务,也就是我们配置websocket的服务地址,并且可以指定是否使用socketjs
+     *
+     * @param registry
+     */
+    @Override
+    public void registerStompEndpoints(StompEndpointRegistry registry) {
+        //注册STOMP协议节点，同时指定使用SockJS协议。
+        registry.addEndpoint("/w-stomp").setAllowedOriginPatterns("*") //处理跨域 单体需要打开 微服务如果在网关中配置了就不需要
+                .withSockJS();
+    }
+
+    @Override
+    public void configureMessageBroker(MessageBrokerRegistry registry) {
+        //服务端发送消息将消息传入带有topic开头订阅的客户端 ，
+        registry.enableSimpleBroker("/topic");
+        // 客户端发送消息时 ，需要以app作为前缀
+        registry.setApplicationDestinationPrefixes("/app"); //这个是客户端发消息时使用 ，作用不同于 registry.addEndpoint()
+    }
+
+    @Bean
+    public ServerEndpointExporter serverEndpointExporter() {
+        return new ServerEndpointExporter();
+    }
+
+}

bd-location/src/main/java/com/ruoyi/bd/socket/wsctl/AudioSocketServer.java

@@ -0,0 +1,54 @@
+package com.ruoyi.bd.socket.wsctl;
+
+import com.ruoyi.bd.service.impl.FFMpegService;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.messaging.handler.annotation.MessageMapping;
+import org.springframework.messaging.handler.annotation.Payload;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+@RestController
+public class AudioSocketServer {
+    @Resource
+    private FFMpegService ffmpegService;
+    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+    private static final String TEMP_FILE_PREFIX = "uploaded_audio_%s";
+
+    @MessageMapping("/audio/stream")
+    public void handleSendMessage(@Payload byte[] message, MessageHeaders messageHeaders) throws IOException {
+//        String sessionId = (String) headerAccessor.getSessionAttributes().get("HTTP_SESSION_ID");
+        Map map = messageHeaders.get("nativeHeaders", Map.class);
+
+//        System.out.println("sessionId = " + message + ",map" + MapUtil.get(map, "camera", ArrayList.class).get(0));
+        // 使用 sessionId 处理消息
+//         可以通过 sessionManager 获取用户信息
+        byte[] audioData = message;
+        File tempFile = File.createTempFile(String.format(TEMP_FILE_PREFIX, "1111"), ".g711");
+        try (FileOutputStream fos = new FileOutputStream(tempFile)) {
+            fos.write(audioData);
+            ffmpegService.writeToRtsp(tempFile.getAbsolutePath());
+        } catch (IOException | InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+//            tempFile.delete();
+        }
+//        executorService.submit(() -> {
+//            try {
+////                System.out.println("tempFile.getAbsolutePath()" + tempFile.getAbsolutePath());
+////                ffmpegService.writeToRtsp(tempFile.getAbsolutePath());
+////            } catch (IOException | InterruptedException e) {
+////                e.printStackTrace();
+////            } finally {
+////                tempFile.delete();
+////            }
+//        });
+    }
+}

bd-location/src/main/java/com/ruoyi/web/controller/bd/DeviceQueryController.java

@@ -0,0 +1,283 @@
+package com.ruoyi.web.controller.bd;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONObject;
+import com.github.pagehelper.PageInfo;
+
+import com.ruoyi.bd.domain.video.Device;
+import com.ruoyi.bd.service.rpc.DeviceQueryService;
+import com.ruoyi.bd.service.video.WvpLogin;
+import com.ruoyi.common.annotation.Anonymous;
+import com.ruoyi.common.response.AppResponse;
+import com.ruoyi.common.response.AppResponseEnum;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiImplicitParams;
+import io.swagger.v3.oas.annotations.Operation;
+import org.apache.commons.compress.utils.IOUtils;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletResponse;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * description  对接wvp服务接口
+ *
+ * @author cy
+ * @date 2023/1/9 10:12
+ */
+@Api(value = "国标设备查询", tags = "视频接入-国标设备查询")
+@RestController
+@RequestMapping("/wvp/api/device/query")
+@Anonymous
+public class DeviceQueryController {
+
+    @Resource
+    DeviceQueryService deviceQueryService;
+
+
+    @Resource
+    WvpLogin wvpLogin;
+
+    @GetMapping("/devices")
+    @Operation(summary = "分页查询国标设备")
+    @ApiImplicitParams({@ApiImplicitParam(name = "page", value = "当前页", required = true), @ApiImplicitParam(name = "count", value = "每页查询数量", required = true)})
+    public AppResponse<PageInfo<Device>> queryDevices(int page, int size) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        deviceQueryService.queryVideoDeviceList(page, size, wvpLogin.getToken(), (resText, request, response) -> {
+            // 成功响应回调
+            appResponse.set(resText);
+        }, (ex, request, response) -> {
+            if (response.getStatusCode() == 401) {
+                wvpLogin.wvpLogin();
+                appResponse.set(queryDevices(page, size));
+            } else {
+                // 异常回调
+                appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+            }
+        });
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+    /**
+     * 使用ID查询国标设备
+     *
+     * @param deviceId 国标ID
+     * @return 国标设备
+     */
+    @Operation(summary = "查询国标设备")
+    @ApiImplicitParam(name = "deviceId", value = "设备国标编号", required = true)
+    @GetMapping("/devices/{deviceId}")
+    public AppResponse<Device> devices(@PathVariable String deviceId) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        deviceQueryService.queryVideoDevice(deviceId, wvpLogin.getToken(), (resText, request, response) -> {
+            // 成功响应回调
+            appResponse.set(resText);
+        }, (ex, request, response) -> {
+            if (response.getStatusCode() == 401) {
+                wvpLogin.wvpLogin();
+                appResponse.set(devices(deviceId));
+            } else {
+                // 异常回调
+                appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+            }
+        });
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+
+    /**
+     * 更新通道信息
+     *
+     * @param deviceId 设备id
+     * @param channel  通道
+     * @return
+     */
+    @Operation(summary = "更新通道信息")
+    @ApiImplicitParams({@ApiImplicitParam(name = "deviceId", value = "设备国标编号", required = true), @ApiImplicitParam(name = "channel", value = "通道信息", required = true)})
+    @PostMapping("/channel/update/{deviceId}")
+    public AppResponse updateChannel(@PathVariable String deviceId, @RequestBody JSONObject channel) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        deviceQueryService.updateChannel(deviceId, channel, wvpLogin.getToken(), (resText, request, response) -> {
+            // 成功响应回调
+            appResponse.set(resText);
+        }, (ex, request, response) -> {
+            if (response.getStatusCode() == 401) {
+                wvpLogin.wvpLogin();
+                appResponse.set(updateChannel(deviceId, channel));
+            } else {
+                // 异常回调
+                appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+            }
+        });
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+    /**
+     * 移除设备
+     *
+     * @param deviceId 设备id
+     * @return
+     */
+    @Operation(summary = "移除设备")
+    @ApiImplicitParam(name = "deviceId", value = "设备国标编号", required = true)
+    @DeleteMapping("/devices/{deviceId}/delete")
+    public AppResponse<String> delete(@PathVariable String deviceId) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        deviceQueryService.delete(deviceId, wvpLogin.getToken(), (resText, request, response) -> {
+            // 成功响应回调
+            appResponse.set(resText);
+        }, (ex, request, response) -> {
+            if (response.getStatusCode() == 401) {
+                wvpLogin.wvpLogin();
+                appResponse.set(delete(deviceId));
+            } else {
+                // 异常回调
+                appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+            }
+        });
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+
+    @GetMapping("/snap/{deviceId}/{channelId}")
+    @Operation(summary = "请求截图")
+    @ApiImplicitParams({@ApiImplicitParam(name = "deviceId", value = "设备国标编号", required = true), @ApiImplicitParam(name = "channelId", value = "通道国标编号", required = true)})
+    public void getSnap(HttpServletResponse resp, @PathVariable String deviceId, @PathVariable String channelId) {
+        deviceQueryService.getSnap(deviceId, channelId, wvpLogin.getToken(), (resText, request, response) -> {
+            // 成功响应回调
+            resp.setContentType(MediaType.IMAGE_PNG_VALUE);
+            try {
+                IOUtils.copy(response.getInputStream(), resp.getOutputStream());
+            } catch (Exception e) {
+                resp.setStatus(HttpServletResponse.SC_NOT_FOUND);
+            }
+        }, (ex, request, response) -> {
+            if (response.getStatusCode() == 401) {
+                wvpLogin.wvpLogin();
+                getSnap(resp, deviceId, channelId);
+            } else {
+                // 异常回调
+                resp.setStatus(HttpServletResponse.SC_NOT_FOUND);
+            }
+        });
+    }
+
+    /**
+     * 修改数据流传输模式
+     *
+     * @param deviceId   设备id
+     * @param streamMode 数据流传输模式
+     * @return
+     */
+    @Operation(summary = "修改数据流传输模式")
+    @ApiImplicitParams({@ApiImplicitParam(name = "deviceId", value = "设备国标编号", required = true), @ApiImplicitParam(name = "streamMode", value = "数据流传输模式, 取值：" + "UDP（udp传输），TCP-ACTIVE（tcp主动模式,暂不支持），TCP-PASSIVE（tcp被动模式）", required = true)})
+    @PostMapping("/transport/{deviceId}/{streamMode}")
+    public AppResponse updateTransport(@PathVariable String deviceId, @PathVariable String streamMode) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        deviceQueryService.updateTransport(deviceId, streamMode, wvpLogin.getToken(), (resText, request, response) -> {
+            // 成功响应回调
+            appResponse.set(resText);
+        }, (ex, request, response) -> {
+            if (response.getStatusCode() == 401) {
+                wvpLogin.wvpLogin();
+                appResponse.set(updateTransport(deviceId, streamMode));
+            } else {
+                // 异常回调
+                appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+            }
+        });
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+    /**
+     * 添加设备信息
+     *
+     * @param device 设备信息
+     * @return
+     */
+    @Operation(summary = "添加设备信息")
+    @ApiImplicitParam(name = "device", value = "设备", required = true)
+    @PostMapping("/device/add")
+    public AppResponse addDevice(@RequestBody JSONObject device) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        deviceQueryService.addDevice(device, wvpLogin.getToken(), (resText, request, response) -> {
+            // 成功响应回调
+            appResponse.set(resText);
+        }, (ex, request, response) -> {
+            if (response.getStatusCode() == 401) {
+                wvpLogin.wvpLogin();
+                appResponse.set(addDevice(device));
+            } else {
+                // 异常回调
+                appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+            }
+        });
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+
+    }
+
+    /**
+     * 更新设备信息
+     *
+     * @param device 设备信息
+     * @return
+     */
+    @Operation(summary = "更新设备信息")
+    @ApiImplicitParam(name = "device", value = "设备", required = true)
+    @PostMapping("/device/update")
+    public AppResponse updateDevice(@RequestBody JSONObject device) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        deviceQueryService.updateDevice(device, wvpLogin.getToken(), (resText, request, response) -> {
+            // 成功响应回调
+            appResponse.set(resText);
+        }, (ex, request, response) -> {
+            if (response.getStatusCode() == 401) {
+                wvpLogin.wvpLogin();
+                appResponse.set(updateDevice(device));
+            } else {
+                // 异常回调
+                appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+            }
+        });
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+
+    @GetMapping("/zlm/getMediaInfo/{mediaServerId}/{app}/{streamId}")
+    @Operation(summary = "编码信息")
+    @ApiImplicitParams({@ApiImplicitParam(name = "mediaServerId", value = "流媒体id", required = true), @ApiImplicitParam(name = "app", value = "流媒体id", required = true), @ApiImplicitParam(name = "streamId", value = "流id", required = true)})
+    public AppResponse<JSONObject> getMediaInfo(@PathVariable String mediaServerId, @PathVariable String app, @PathVariable String streamId) {
+        AtomicReference<JSONObject> appResponse = new AtomicReference<>(new JSONObject());
+        deviceQueryService.getMediaInfo(mediaServerId, app, streamId, wvpLogin.getToken(), (resText, request, response) -> {
+            // 成功响应回调
+            appResponse.set(resText);
+        }, (ex, request, response) -> {
+            if (response.getStatusCode() == 401) {
+                wvpLogin.wvpLogin();
+                appResponse.set(getMediaInfo(mediaServerId, app, streamId).getData());
+            } else {
+                // 异常回调
+                appResponse.set(JSON.parseObject(response.getContent(), JSONObject.class));
+            }
+        });
+        return AppResponse.success(appResponse.get());
+    }
+
+}

bd-location/src/main/java/com/ruoyi/web/controller/bd/PlayController.java

@@ -0,0 +1,185 @@
+package com.ruoyi.web.controller.bd;
+
+import com.alibaba.fastjson2.JSON;
+import com.ruoyi.bd.domain.video.PlayConvertObj;
+import com.ruoyi.bd.domain.video.PlayStopObj;
+import com.ruoyi.bd.domain.video.StreamContent;
+import com.ruoyi.bd.service.rpc.PlayService;
+import com.ruoyi.bd.service.video.WvpLogin;
+import com.ruoyi.bd.service.video.WvpService;
+import com.ruoyi.common.annotation.Anonymous;
+import com.ruoyi.common.response.AppResponse;
+import com.ruoyi.common.response.AppResponseEnum;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiImplicitParams;
+import io.swagger.v3.oas.annotations.Operation;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * description
+ *
+ * @author cy
+ * @date 2023/1/11 10:27
+ */
+
+@Api(value = "国标设备点播", tags = "视频接入-国标设备点播")
+@CrossOrigin
+@RestController
+@RequestMapping("/wvp/api/play")
+@Anonymous
+public class PlayController {
+
+    @Resource
+    WvpLogin wvpLogin;
+
+    @Resource
+    PlayService playService;
+
+    @Resource
+    WvpService wvpService;
+
+    @Operation(summary = "开始点播")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "deviceId", value = "设备国标编号", required = true),
+            @ApiImplicitParam(name = "channelId", value = "通道国标编号", required = true)
+    })
+    @GetMapping("/start/{deviceId}/{channelId}")
+    public AppResponse<StreamContent> play(@PathVariable String deviceId, @PathVariable String channelId) {
+        AppResponse<StreamContent> appResponse = wvpService.play(deviceId, channelId);
+        appResponse.setCode(AppResponseEnum.SUCCESS.getCode());
+        return appResponse;
+    }
+
+    @Operation(summary = "停止点播")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "deviceId", value = "设备国标编号", required = true),
+            @ApiImplicitParam(name = "channelId", value = "通道国标编号", required = true)
+    })
+    @GetMapping("/stop/{deviceId}/{channelId}")
+    public AppResponse<PlayStopObj> playStop(@PathVariable String deviceId, @PathVariable String channelId) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        playService.playStop(deviceId, channelId, wvpLogin.getToken(), (resText, request, response) -> {
+                    // 成功响应回调
+                    appResponse.set(resText);
+                },
+                (ex, request, response) -> {
+                    if (response.getStatusCode() == 401) {
+                        wvpLogin.wvpLogin();
+                        appResponse.set(playStop(deviceId, channelId));
+                    } else {
+                        // 异常回调
+                        appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+                    }
+                });
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+    /**
+     * 将不是h264的视频通过ffmpeg 转码为h264 + aac
+     *
+     * @param streamId 流ID
+     */
+    @Operation(summary = "将不是h264的视频通过ffmpeg 转码为h264 + aac")
+    @ApiImplicitParam(name = "streamId", value = "视频流ID", required = true)
+    @PostMapping("/convert/{streamId}")
+    public AppResponse<PlayConvertObj> playConvert(@PathVariable String streamId) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        playService.playConvert(streamId, wvpLogin.getToken(), (resText, request, response) -> {
+                    // 成功响应回调
+                    appResponse.set(resText);
+                },
+                (ex, request, response) -> {
+                    if (response.getStatusCode() == 401) {
+                        wvpLogin.wvpLogin();
+                        appResponse.set(playConvert(streamId));
+                    } else {
+                        // 异常回调
+                        appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+                    }
+                });
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+    /**
+     * 结束转码
+     */
+    @Operation(summary = "结束转码")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "key", value = "视频流key", required = true),
+            @ApiImplicitParam(name = "mediaServerId", value = "流媒体服务ID", required = true)
+    })
+    @PostMapping("/convertStop/{key}")
+    public AppResponse playConvertStop(@PathVariable String key, String mediaServerId) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        playService.playConvertStop(key, mediaServerId, wvpLogin.getToken(), (resText, request, response) -> {
+                    // 成功响应回调
+                    appResponse.set(resText);
+                },
+                (ex, request, response) -> {
+                    if (response.getStatusCode() == 401) {
+                        wvpLogin.wvpLogin();
+                        appResponse.set(playConvertStop(key, mediaServerId));
+                    } else {
+                        // 异常回调
+                        appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+                    }
+                });
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+    @GetMapping("/broadcast/{deviceId}/{channelId}")
+    public AppResponse<StreamContent> broadcast(@PathVariable String deviceId, @PathVariable String channelId, @RequestParam(required = false, defaultValue = "30") String timeout, @RequestParam(required = false, defaultValue = "true") String broadcastMode) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        playService.broadcast(deviceId, channelId, wvpLogin.getToken(), timeout, broadcastMode, (resText, request, response) -> {
+                    // 成功响应回调
+                    appResponse.set(resText);
+                },
+                (ex, request, response) -> {
+                    if (response.getStatusCode() == 401) {
+                        wvpLogin.wvpLogin();
+                        appResponse.set(playStop(deviceId, channelId));
+                    } else {
+                        // 异常回调
+                        appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+                    }
+                });
+
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+    @GetMapping("/broadcast/stop/{deviceId}/{channelId}")
+    public AppResponse<StreamContent> broadcaststop(@PathVariable String deviceId, @PathVariable String channelId, @RequestParam(required = false, defaultValue = "30") String timeout, @RequestParam(required = false, defaultValue = "true") String broadcastMode) {
+        AtomicReference<AppResponse> appResponse = new AtomicReference<>(new AppResponse());
+        playService.broadcaststop(deviceId, channelId, wvpLogin.getToken(), timeout, broadcastMode, (resText, request, response) -> {
+                    // 成功响应回调
+                    appResponse.set(resText);
+                },
+                (ex, request, response) -> {
+                    if (response.getStatusCode() == 401) {
+                        wvpLogin.wvpLogin();
+                        appResponse.set(playStop(deviceId, channelId));
+                    } else {
+                        // 异常回调
+                        appResponse.set(JSON.parseObject(response.getContent(), AppResponse.class));
+                    }
+                });
+
+        AppResponse res = appResponse.get();
+        res.setCode(AppResponseEnum.SUCCESS.getCode());
+        return res;
+    }
+
+
+}

bd-location/src/main/resources/application-local.yml

@@ -84,8 +84,8 @@ spring:
 mqtt:
   client:
     enabled: true
-    ip: 200.200.19.121
-    port: 31005
+    ip: xt.wenhq.top
+    port: 8581
     name: uwb-location-client
     client-id: uwb-000001
     global-subscribe:
@@ -101,7 +101,7 @@ mqtt:
       enabled: false
 bd:
   mqtt:
-    enabled: true
+    enabled: false
   uwb:
     enabled: false
     uwb-socket: ws://172.192.13.77:2223/socket/websocket/pollingArea

bd-location/src/main/resources/application.yml

@@ -78,6 +78,10 @@ forest:
   log-response-status: true
   ## 打开/关闭Forest响应内容日志（默认为 false）
   log-response-content: true
+  variables:
+    baseHost: http://36.152.142.44:40052
+    queryPath: /api/device/query
+    playPath: /api/play
 # token配置
 token:
   # 令牌自定义标识

bd-location/src/main/resources/logback.xml

@@ -74,9 +74,9 @@
 	<!-- 系统模块日志级别控制  -->
 	<logger name="com.ruoyi" level="info" />
 	<!-- Spring日志级别控制  -->
-	<logger name="org.springframework" level="warn" />
+	<logger name="org.springframework" level="debug" />
 
-	<root level="info">
+	<root level="debug">
 		<appender-ref ref="console" />
 	</root>
 

package-lock.json

@@ -0,0 +1,382 @@
+{
+  "name": "hh-vue",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "stompjs": "^2.3.3"
+      }
+    },
+    "node_modules/bufferutil": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmmirror.com/bufferutil/-/bufferutil-4.0.8.tgz",
+      "integrity": "sha512-4T53u4PdgsXqKaIctwF8ifXlRTTmEPJ8iEPWFdGZvcf7sbwYo6FKFEX9eNNAnzFZ7EzJAQ3CJeOtCRA4rDp7Pw==",
+      "hasInstallScript": true,
+      "optional": true,
+      "dependencies": {
+        "node-gyp-build": "^4.3.0"
+      },
+      "engines": {
+        "node": ">=6.14.2"
+      }
+    },
+    "node_modules/d": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/d/-/d-1.0.2.tgz",
+      "integrity": "sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==",
+      "optional": true,
+      "dependencies": {
+        "es5-ext": "^0.10.64",
+        "type": "^2.7.2"
+      },
+      "engines": {
+        "node": ">=0.12"
+      }
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmmirror.com/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "optional": true,
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/es5-ext": {
+      "version": "0.10.64",
+      "resolved": "https://registry.npmmirror.com/es5-ext/-/es5-ext-0.10.64.tgz",
+      "integrity": "sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==",
+      "hasInstallScript": true,
+      "optional": true,
+      "dependencies": {
+        "es6-iterator": "^2.0.3",
+        "es6-symbol": "^3.1.3",
+        "esniff": "^2.0.1",
+        "next-tick": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/es6-iterator": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmmirror.com/es6-iterator/-/es6-iterator-2.0.3.tgz",
+      "integrity": "sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==",
+      "optional": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "^0.10.35",
+        "es6-symbol": "^3.1.1"
+      }
+    },
+    "node_modules/es6-symbol": {
+      "version": "3.1.4",
+      "resolved": "https://registry.npmmirror.com/es6-symbol/-/es6-symbol-3.1.4.tgz",
+      "integrity": "sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==",
+      "optional": true,
+      "dependencies": {
+        "d": "^1.0.2",
+        "ext": "^1.7.0"
+      },
+      "engines": {
+        "node": ">=0.12"
+      }
+    },
+    "node_modules/esniff": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/esniff/-/esniff-2.0.1.tgz",
+      "integrity": "sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==",
+      "optional": true,
+      "dependencies": {
+        "d": "^1.0.1",
+        "es5-ext": "^0.10.62",
+        "event-emitter": "^0.3.5",
+        "type": "^2.7.2"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/event-emitter": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmmirror.com/event-emitter/-/event-emitter-0.3.5.tgz",
+      "integrity": "sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==",
+      "optional": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "~0.10.14"
+      }
+    },
+    "node_modules/ext": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmmirror.com/ext/-/ext-1.7.0.tgz",
+      "integrity": "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==",
+      "optional": true,
+      "dependencies": {
+        "type": "^2.7.2"
+      }
+    },
+    "node_modules/is-typedarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/is-typedarray/-/is-typedarray-1.0.0.tgz",
+      "integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==",
+      "optional": true
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "optional": true
+    },
+    "node_modules/next-tick": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/next-tick/-/next-tick-1.1.0.tgz",
+      "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==",
+      "optional": true
+    },
+    "node_modules/node-gyp-build": {
+      "version": "4.8.3",
+      "resolved": "https://registry.npmmirror.com/node-gyp-build/-/node-gyp-build-4.8.3.tgz",
+      "integrity": "sha512-EMS95CMJzdoSKoIiXo8pxKoL8DYxwIZXYlLmgPb8KUv794abpnLK6ynsCAWNliOjREKruYKdzbh76HHYUHX7nw==",
+      "optional": true,
+      "bin": {
+        "node-gyp-build": "bin.js",
+        "node-gyp-build-optional": "optional.js",
+        "node-gyp-build-test": "build-test.js"
+      }
+    },
+    "node_modules/stompjs": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmmirror.com/stompjs/-/stompjs-2.3.3.tgz",
+      "integrity": "sha512-5l/Ogz0DTFW7TrpHF0LAETGqM/so8UxNJvYZjJKqcX31EVprSQgnGkO80tZctPC/lFBDUrSFiTG3xd0R27XAIA==",
+      "optionalDependencies": {
+        "websocket": "latest"
+      }
+    },
+    "node_modules/type": {
+      "version": "2.7.3",
+      "resolved": "https://registry.npmmirror.com/type/-/type-2.7.3.tgz",
+      "integrity": "sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==",
+      "optional": true
+    },
+    "node_modules/typedarray-to-buffer": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmmirror.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz",
+      "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==",
+      "optional": true,
+      "dependencies": {
+        "is-typedarray": "^1.0.0"
+      }
+    },
+    "node_modules/utf-8-validate": {
+      "version": "5.0.10",
+      "resolved": "https://registry.npmmirror.com/utf-8-validate/-/utf-8-validate-5.0.10.tgz",
+      "integrity": "sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==",
+      "hasInstallScript": true,
+      "optional": true,
+      "dependencies": {
+        "node-gyp-build": "^4.3.0"
+      },
+      "engines": {
+        "node": ">=6.14.2"
+      }
+    },
+    "node_modules/websocket": {
+      "version": "1.0.35",
+      "resolved": "https://registry.npmmirror.com/websocket/-/websocket-1.0.35.tgz",
+      "integrity": "sha512-/REy6amwPZl44DDzvRCkaI1q1bIiQB0mEFQLUrhz3z2EK91cp3n72rAjUlrTP0zV22HJIUOVHQGPxhFRjxjt+Q==",
+      "optional": true,
+      "dependencies": {
+        "bufferutil": "^4.0.1",
+        "debug": "^2.2.0",
+        "es5-ext": "^0.10.63",
+        "typedarray-to-buffer": "^3.1.5",
+        "utf-8-validate": "^5.0.2",
+        "yaeti": "^0.0.6"
+      },
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/yaeti": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmmirror.com/yaeti/-/yaeti-0.0.6.tgz",
+      "integrity": "sha512-MvQa//+KcZCUkBTIC9blM+CU9J2GzuTytsOUwf2lidtvkx/6gnEp1QvJv34t9vdjhFmha/mUiNDbN0D0mJWdug==",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.32"
+      }
+    }
+  },
+  "dependencies": {
+    "bufferutil": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmmirror.com/bufferutil/-/bufferutil-4.0.8.tgz",
+      "integrity": "sha512-4T53u4PdgsXqKaIctwF8ifXlRTTmEPJ8iEPWFdGZvcf7sbwYo6FKFEX9eNNAnzFZ7EzJAQ3CJeOtCRA4rDp7Pw==",
+      "optional": true,
+      "requires": {
+        "node-gyp-build": "^4.3.0"
+      }
+    },
+    "d": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/d/-/d-1.0.2.tgz",
+      "integrity": "sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==",
+      "optional": true,
+      "requires": {
+        "es5-ext": "^0.10.64",
+        "type": "^2.7.2"
+      }
+    },
+    "debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmmirror.com/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "optional": true,
+      "requires": {
+        "ms": "2.0.0"
+      }
+    },
+    "es5-ext": {
+      "version": "0.10.64",
+      "resolved": "https://registry.npmmirror.com/es5-ext/-/es5-ext-0.10.64.tgz",
+      "integrity": "sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==",
+      "optional": true,
+      "requires": {
+        "es6-iterator": "^2.0.3",
+        "es6-symbol": "^3.1.3",
+        "esniff": "^2.0.1",
+        "next-tick": "^1.1.0"
+      }
+    },
+    "es6-iterator": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmmirror.com/es6-iterator/-/es6-iterator-2.0.3.tgz",
+      "integrity": "sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==",
+      "optional": true,
+      "requires": {
+        "d": "1",
+        "es5-ext": "^0.10.35",
+        "es6-symbol": "^3.1.1"
+      }
+    },
+    "es6-symbol": {
+      "version": "3.1.4",
+      "resolved": "https://registry.npmmirror.com/es6-symbol/-/es6-symbol-3.1.4.tgz",
+      "integrity": "sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==",
+      "optional": true,
+      "requires": {
+        "d": "^1.0.2",
+        "ext": "^1.7.0"
+      }
+    },
+    "esniff": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/esniff/-/esniff-2.0.1.tgz",
+      "integrity": "sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==",
+      "optional": true,
+      "requires": {
+        "d": "^1.0.1",
+        "es5-ext": "^0.10.62",
+        "event-emitter": "^0.3.5",
+        "type": "^2.7.2"
+      }
+    },
+    "event-emitter": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmmirror.com/event-emitter/-/event-emitter-0.3.5.tgz",
+      "integrity": "sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==",
+      "optional": true,
+      "requires": {
+        "d": "1",
+        "es5-ext": "~0.10.14"
+      }
+    },
+    "ext": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmmirror.com/ext/-/ext-1.7.0.tgz",
+      "integrity": "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==",
+      "optional": true,
+      "requires": {
+        "type": "^2.7.2"
+      }
+    },
+    "is-typedarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/is-typedarray/-/is-typedarray-1.0.0.tgz",
+      "integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==",
+      "optional": true
+    },
+    "ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "optional": true
+    },
+    "next-tick": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/next-tick/-/next-tick-1.1.0.tgz",
+      "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==",
+      "optional": true
+    },
+    "node-gyp-build": {
+      "version": "4.8.3",
+      "resolved": "https://registry.npmmirror.com/node-gyp-build/-/node-gyp-build-4.8.3.tgz",
+      "integrity": "sha512-EMS95CMJzdoSKoIiXo8pxKoL8DYxwIZXYlLmgPb8KUv794abpnLK6ynsCAWNliOjREKruYKdzbh76HHYUHX7nw==",
+      "optional": true
+    },
+    "stompjs": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmmirror.com/stompjs/-/stompjs-2.3.3.tgz",
+      "integrity": "sha512-5l/Ogz0DTFW7TrpHF0LAETGqM/so8UxNJvYZjJKqcX31EVprSQgnGkO80tZctPC/lFBDUrSFiTG3xd0R27XAIA==",
+      "requires": {
+        "websocket": "latest"
+      }
+    },
+    "type": {
+      "version": "2.7.3",
+      "resolved": "https://registry.npmmirror.com/type/-/type-2.7.3.tgz",
+      "integrity": "sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==",
+      "optional": true
+    },
+    "typedarray-to-buffer": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmmirror.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz",
+      "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==",
+      "optional": true,
+      "requires": {
+        "is-typedarray": "^1.0.0"
+      }
+    },
+    "utf-8-validate": {
+      "version": "5.0.10",
+      "resolved": "https://registry.npmmirror.com/utf-8-validate/-/utf-8-validate-5.0.10.tgz",
+      "integrity": "sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==",
+      "optional": true,
+      "requires": {
+        "node-gyp-build": "^4.3.0"
+      }
+    },
+    "websocket": {
+      "version": "1.0.35",
+      "resolved": "https://registry.npmmirror.com/websocket/-/websocket-1.0.35.tgz",
+      "integrity": "sha512-/REy6amwPZl44DDzvRCkaI1q1bIiQB0mEFQLUrhz3z2EK91cp3n72rAjUlrTP0zV22HJIUOVHQGPxhFRjxjt+Q==",
+      "optional": true,
+      "requires": {
+        "bufferutil": "^4.0.1",
+        "debug": "^2.2.0",
+        "es5-ext": "^0.10.63",
+        "typedarray-to-buffer": "^3.1.5",
+        "utf-8-validate": "^5.0.2",
+        "yaeti": "^0.0.6"
+      }
+    },
+    "yaeti": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmmirror.com/yaeti/-/yaeti-0.0.6.tgz",
+      "integrity": "sha512-MvQa//+KcZCUkBTIC9blM+CU9J2GzuTytsOUwf2lidtvkx/6gnEp1QvJv34t9vdjhFmha/mUiNDbN0D0mJWdug==",
+      "optional": true
+    }
+  }
+}

package.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "sockjs-client": "^1.6.1",
+    "stompjs": "^2.3.3"
+  }
+}

ruoyi-common/src/main/java/com/ruoyi/common/response/AppResponse.java

@@ -0,0 +1,118 @@
+package com.ruoyi.common.response;
+
+
+import java.io.Serializable;
+
+/**
+ * Http REST 响应体
+ *
+ * @author srforever
+ * @date 2021/5/22 0:27
+ */
+//@ApiModel("响应体")
+//@Data
+public class AppResponse<V> implements Serializable {
+
+    private static final long serialVersionUID = -8713837118340960775L;
+
+    private Integer code;
+
+    private String message;
+
+    private String msg;
+
+    private V data;
+
+    public void setData(V data) {
+        this.data = data;
+    }
+
+    public V getData() {
+        return data;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public String getMsg() {
+        return msg;
+    }
+
+    public void setMsg(String msg) {
+        this.msg = msg;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public void setCode(Integer code) {
+        this.code = code;
+    }
+
+    public Long getCount() {
+        return count;
+    }
+
+    public void setCount(Long count) {
+        this.count = count;
+    }
+
+    private Long count;
+
+    public AppResponse() {
+    }
+
+    private AppResponse(Integer code, String message) {
+        this.code = code;
+        this.message = message;
+    }
+
+    private AppResponse(Integer code, String message, V data) {
+        this.code = code;
+        this.message = message;
+        this.data = data;
+    }
+
+    private AppResponse(Integer code, String message, V data, Long count) {
+        this.code = code;
+        this.message = message;
+        this.data = data;
+        this.count = count;
+    }
+
+    public static <T> AppResponse<T> success() {
+        AppResponseEnum appResponseEnum = AppResponseEnum.SUCCESS;
+        return new AppResponse<>(appResponseEnum.getCode(), appResponseEnum.getMsg());
+    }
+
+    public static <T> AppResponse<T> success(T o) {
+        return new AppResponse<>(AppResponseEnum.SUCCESS.getCode(),
+                AppResponseEnum.SUCCESS.getMsg(),
+                o);
+    }
+
+    public static <T> AppResponse<T> success(T o, Long count) {
+        return new AppResponse<>(AppResponseEnum.SUCCESS.getCode(),
+                AppResponseEnum.SUCCESS.getMsg(),
+                o, count);
+    }
+
+    public static <T> AppResponse<T> fail() {
+        return new AppResponse<>(AppResponseEnum.SYSTEM_ERROR.getCode(),
+                AppResponseEnum.SYSTEM_ERROR.getMsg());
+    }
+
+    public static <T> AppResponse<T> fail(Integer code, String msg) {
+        return new AppResponse<T>(code, msg);
+    }
+
+    public static <T> AppResponse<T> fail(AppResponseEnum appResponseEnum) {
+        return new AppResponse<>(appResponseEnum.getCode(), appResponseEnum.getMsg());
+    }
+}

ruoyi-common/src/main/java/com/ruoyi/common/response/AppResponseEnum.java

@@ -0,0 +1,629 @@
+package com.ruoyi.common.response;
+
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+
+
+/**
+ * 应用状态枚举
+ *
+ * @author srforever
+ * @date 2021/5/22 0:28
+ */
+
+public enum AppResponseEnum {
+    /**
+     * token失效
+     */
+    OAUTH_UNSUPPORTED_GRANT_TYPE(401, "grant不被授权服务器所支持!"),
+    OAUTH_INVALID_GRANT(401, "grant/refresh token/code无效!"),
+    OAUTH_TOKEN_NOT_AUTH(401, "token是错误的或已经过期!"),
+    /**
+     * 状态枚举
+     */
+    NEED_LOGIN(100010, "未登录"),
+    USER_PASSWORD_ERROR(100011, "用户名或密码错误！"),
+    REPEAT_REGISTER(100020, "该用户已注册"),
+    USER_NOT_EXIST(100030, "不存在该用户"),
+    PASSWORD_ERROR(100040, "密码错误"),
+    EMPTY_USERNAME(100050, "用户名为空"),
+    EMPTY_PASSWORD(100060, "密码为空"),
+    NO_AUTH(100070, "权限不足,拒绝访问!"),
+    DEL_FAILURE(10080, "删除失败"),
+    USER_DISABLE(10081, "账号已经被禁用,请联系客服!"),
+    USER_LOCK(10082, "账号已经被锁定,请5分钟后登录!"),
+
+    APP_ACCESS_NOT_EXIST(10100, "账号不存在"),
+    APP_ACCESS_CODE_ERROR(10101, "认证失败"),
+    APP_ACCESS_NOT_AUTH(10102, "无权访问"),
+
+    ACCOUNT_HAS_BEEN_BOUND(10103, "系统账号已绑定，请勿重复绑定！"),
+    ACCOUNT_HAS_NOT_BOUND(10104, "该账号未绑定，请登录后绑定第三方账号！"),
+
+    SUCCESS(200010, "请求成功"),
+
+    NOT_FOUND(404000, "系统错误"),
+
+    PARAMS_REQUIRED(404001, "缺少必填参数"),
+
+    SYSTEM_ERROR(500000, "系统错误"),
+
+    SYSTEM_DATA_ERROR(500001, "数据异常"),
+
+    UNKNOWN_ERROR(500100, "未知错误"),
+    STRING_2_DATE_FORMAT_ERROR(500100, "string转日期错误"),
+    FILE_READ_FAIL(500102, "文件读取失败"),
+
+    /**
+     * 产品
+     */
+    PRODUCT_ERROR(500500, "产品未知错误"),
+    PRODUCT_QUERY_ERROR(500501, "查询产品信息失败"),
+    PRODUCT_EXIST_ERROR(500502, "产品名称已存在"),
+    PRODUCT_NOT_EXIST_ERROR(500503, "无此产品信息"),
+    PRODUCT_DELETE_ERROR(500504, "删除产品失败"),
+    PRODUCT_UPDATE_ERROR(500505, "更新产品失败"),
+    PRODUCT_RELEASE_ERROR(500506, "产品已发布，无法修改ProductKey！"),
+    PRODUCTKEY_EXIST_ERROR(500507, "产品productKey已存在，请重新输入！"),
+    PRODUCT_PROHIBIT_ERROR(500508, "停用产品失败"),
+    PRODUCT_RECOVERY_ERROR(500509, "发布产品失败"),
+    PRODUCT_DEVICE_EXIST_ERROR(500509, "产品下有设备,请先删除或解绑设备！"),
+    PRODUCT_DEVICETYPE_ERROR(500510, "设备类型有误"),
+    PRODUCT_NETWORK_ERROR(500511, "入网方式有误"),
+    PRODUCT_TPTYPE_ERROR(500512, "网络组件有误"),
+    PRODUCT_ERROR2(500513, "产品错误"),
+    /**
+     * 产品分类
+     */
+    PRODUCT_GROUP_ERROR(500520, "产品分组未知错误"),
+    PRODUCT_GROUP_NOT_EXIST_ERROR(500521, "无此产品信息"),
+    PRODUCT_GROUP_QUERY_ERROR(500522, "查询产品分组信息失败"),
+    PRODUCT_GROUP_SAVE_ERROR(500523, "新增产品分组失败"),
+    PRODUCT_GROUP_PARENT_ERROR(500524, "产品分组父节点不存在"),
+    PRODUCT_GROUP_LEVEL_ERROR(500525, "产品分类最多3层结构"),
+    PRODUCT_GROUP_UPDATE_ERROR(500526, "更新产品分组失败"),
+    PRODUCT_GROUP_DELETE_PRODUCT_ERROR(500527, "此产品分类有产品正在使用不可删除"),
+    PRODUCT_GROUP_DELETE_GROUP_ERROR(500528, "此产品分类下有其他产品分类，请先删除节点下方产品分类！"),
+    PRODUCT_GROUP_NAME_EXIST_ERROR(500502, "产品分类名称已存在"),
+    PRODUCT_GROUP_DELETE_ERROR(500526, "删除产品分组失败"),
+
+    /**
+     * 协议管理
+     */
+    PROTOCOL_ERROR(500540, "协议管理未知错误"),
+    PROTOCOL_QUERY_ERROR(500541, "获取协议信息失败"),
+    PROTOCOL_EXIST_ERROR(500542, "协议名称已存在"),
+    PROTOCOL_NOT_EXIST_ERROR(500543, "无此协议信息"),
+    PROTOCOL_START_ERROR(500544, "协议已启动,不可修改、删除"),
+    PROTOCOL_PRODUCT_ERROR(500545, "此协议有产品正在使用不可删除！"),
+    PROTOCOL_DELETE_ERROR(500546, "删除协议失败"),
+    PROTOCOL_UPDATE_ERROR(500527, "更新协议失败"),
+    PROTOCOL_PROHIBIT_ERROR(500528, "停用协议失败"),
+    PROTOCOL_RECOVERY_ERROR(500529, "发布协议失败"),
+    PROTOCOL_JAR_ERROR(500530, "jar包上传有误，请重新上传！"),
+    PROTOCOL_TYPE_ERROR(500531, "协议类型有误！"),
+    PROTOCOL_TYPE_PARAMS_ERROR(500532, "选取相应协议类型之后，参数不完整！"),
+    PROTOCOL_SAVE_ERROR(500533, "协议新增失败"),
+    PROTOCOL_NAME_REPEAT(500534, "协议名称重复"),
+    PROTOCOL_JSON_CONFIG_ERROR(500535, "json配置错误，不能同时配置数组和单个对象"),
+    PROTOCOL_DEVICE_BINDED(500536, "协议已绑定设备，不可删除"),
+
+    /**
+     * 告警设置
+     */
+    ALARM_ERROR(500560, "告警设置未知错误"),
+    ALARM_QUERY_ERROR(500561, "获取告警设置失败"),
+    ALARM_EXIST_ERROR(500562, "告警设置名称已存在"),
+    ALARM_NOT_EXIST_ERROR(500563, "无此告警设置"),
+    ALARM_START_ERROR(500564, "告警设置已启动,不可修改、删除"),
+    ALARM_SAVE_ERROR(500565, "告警设置新增失败"),
+    ALARM_DELETE_ERROR(500566, "删除告警设置失败"),
+    ALARM_UPDATE_ERROR(500567, "更新告警设置失败"),
+    ALARM_UPDATESTATE_ERROR(500568, "告警设置状态修改失败"),
+    ALARM_RULE_ERROR(500569, "告警规则未知错误"),
+    ALARM_RULE_QUERY_ERROR(500570, "获取告警规则失败"),
+    ALARM_RULE_EXIST_ERROR(500571, "告警规则名称已存在"),
+    ALARM_RULE_NOT_EXIST_ERROR(500572, "无此告警规则"),
+    ALARM_RULE_START_ERROR(500573, "告警设置已启动，所属告警规则不可新增、修改、删除"),
+    ALARM_RULE_SAVE_ERROR(500574, "告警规则新增失败"),
+    ALARM_RULE_DELETE_ERROR(500575, "删除告警规则失败"),
+    ALARM_RULE_UPDATE_ERROR(500576, "更新告警规则失败"),
+    ALARM_RULE_UPDATESTATE_ERROR(500577, "告警规则状态修改失败"),
+    ALARM_RULE_SETTINGID_ERROR(500578, "告警设置id不可为空"),
+    ALARM_RULE_SETTING_ERROR(500579, "此告警规则所属告警设置有误"),
+    ALARM_RESTRICTIONS_ERROR(505560, "执行限制有误"),
+    ALARM_TRIGGER_TYPE_ERROR(505561, "触发类型有误"),
+    ALARM_ACTIVE_TYPE_ERROR(505562, "活动类型有误"),
+    ALARM_NOTIFY_TYPE_ERROR(505563, "动作类型有误"),
+    ALARM_NOTICE_TYPE_ERROR(505564, "消息通知类型有误"),
+    ALARM_TEMPLATE_ERROR(505565, "通知模板有误"),
+    ALARM_IN_USE_DELETE_ERROR(500566, "告警设置被使用,删除失败"),
+    ALARM_RULE_NOTIFY_SEND_LIMIT_FAIL(500567, "通知告警邮件发送次数超过上限，邮件不发送"),
+    ALARM_RULE_RATES_LIMIT_FAIL(500568, "规则引擎告警次数上限，请稍后再试"),
+    ALARM_RULE_CONTINUE_LIMIT_FAIL(500569, "规则引擎未到达连续触发次数，暂不触发"),
+    ALARM_RULE_NOT_START_FAIL(500570, "规则引擎未开启，不能执行"),
+    ALARM_LEVEL_LEVEL_REPEAT(500571, "告警等级编码重复"),
+    ALARM_LEVEL_NAME_REPEAT(500572, "告警等级名称重复"),
+    ALARM_LEVEL_IN_USE_DELETE_FAIL(500573, "告警等级正在使用，删除失败"),
+    ALARM_TEMPLATE_NOT_NEED_PARAM_ERROR(505565, "通知模板不需要动态参数"),
+
+    /**
+     * 物模型
+     */
+    METADATA_ERROR(500580, "物模型未知错误"),
+    METADATA_QUERY_ERROR(500581, "获取物模型失败"),
+    METADATA_NAME_EXIST_ERROR(500582, "物模型名称已存在"),
+    METADATA_NOT_EXIST_ERROR(500583, "物模型不存在"),
+    METADATA_START_ERROR(500584, "物模型已启动,不可修改、删除"),
+    METADATA_SAVE_ERROR(500585, "物模型新增失败"),
+    METADATA_DELETE_ERROR(500586, "删除物模型失败"),
+    METADATA_UPDATE_ERROR(500587, "更新物模型失败"),
+    METADATA_UPDATESTATE_ERROR(500588, "物模型状态修改失败"),
+    METADATA_PRODUCT_ERROR(500589, "此物模型有产品正在使用不可删除！"),
+    METADATA_ANALYSIS_ERROR(500590, "物模型解析有误！"),
+    METADATA_IMPORT_ERROR(500591, "物模型导入有误！"),
+    METADATA_IMPORT_NOT_EMPTY_ERROR(500591, "物模型导入数据不能为空！"),
+    METADATA_IMPORT_PROPERTIES_ERROR(500592, "物模型属性导入有误！"),
+    METADATA_IMPORT_EVENTS_ERROR(500593, "物模型事件导入有误！"),
+    METADATA_IMPORT_SERVICES_ERROR(500594, "物模型功能导入有误！"),
+    METADATA_DOWNLOAD_ERROR(500595, "物模型导出有误！"),
+    METADATAEVENT_NOT_EXIST_ERROR(500596, "无此物模型事件信息"),
+    METADATAEVENT_DELETE_ERROR(501597, "删除物模型属性失败"),
+    METADATAEVENT_UPDATE_ERROR(502598, "更新物模型属性失败"),
+    METADATAPROPERTY_NOT_EXIST_ERROR(500599, "无此物模型属性信息"),
+    METADATAPROPERTY_DELETE_ERROR(500600, "删除物模型属性失败"),
+    METADATAPROPERTY_UPDATE_ERROR(500601, "更新物模型属性失败"),
+    METADATASERVICE_NOT_EXIST_ERROR(500602, "无此物模型服务信息"),
+    METADATASERVICE_DELETE_ERROR(500603, "删除物模型服务失败"),
+    METADATASERVICE_UPDATE_ERROR(500604, "更新物模型服务失败"),
+    METADATAPROPERTY_DOWNLOAD_ERROR(500605, "物模型属性模板下载有误！"),
+    METADATAPROPERTY_IMPORT_ERROR(500606, "物模型属性模板下载有误！"),
+    METADATA_PROPERTY_IDENTIFIER_EXIST_ERROR(500607, "属性标识符已存在，该物模型下所有模块的属性标识符都不能重复！"),
+    METADATA_PROPERTY_IDENTIFIER_EXIST_ERROR2(500607, "导入的数据中，属性标识符重复！"),
+    METADATA_EVENT_IDENTIFIER_EXIST_ERROR(500608, "事件标识符已存在"),
+    METADATA_FUNCTION_IDENTIFIER_EXIST_ERROR(500609, "服务标识符已存在"),
+    METADATA_TYPE_ERROR(5006090, "数据格式有误"),
+    METADATA_DATA_ERROR(5006091, "取值有误"),
+    METADATAEVENT_TYPE_ERROR(5006092, "事件级别有误"),
+    METADATA_PARAMS_ERROR(5006093, "参数有误"),
+    METADATA_CODE_EXIST_ERROR(5006094, "物模型编码已存在"),
+    METADATA_MODULE_NAME_ERROR(5006095, "模块名称重复！"),
+    METADATA_MODULE_CODE_ERROR(5006096, "模块标识重复！"),
+    METADATA_PROPERTY_IDENTIFIER_ILLEGAL_ERROR(5006097, "属性标识符包含非法字符串！"),
+    /**
+     * 设备
+     */
+    DEVICE_NOT_EXIST(500610, "设备不存在"),
+    DEVICE_ERROR(500610, "设备未知错误"),
+    // 根据id
+    DEVICE_QUERY_ERROR(500611, "查询设备信息失败"),
+    DEVICE_SAVE_ERROR(500612, "新增设备失败"),
+    // 在某个产品下
+    DEVICE_EXIST_ERROR(500613, "设备编码已存在"),
+    DEVICE_DELETE_ERROR(500614, "删除设备失败"),
+    DEVICE_DELETE_PROHIBIT(500615, "删除失败，设备存在子设备"),
+    DEVICE_UPDATE_ERROR(500616, "修改设备失败"),
+    DEVICE_UPDATE_PROHIBIT(500617, "修改失败，设备正在运行"),
+    DEVICE_ACTIVATE_ERROR(500618, "设备激活失败"),
+    DEVICE_PROHIBIT_ERROR(500619, "设备禁用失败"),
+    DEVICE_BIND_ERROR(500620, "设备绑定失败"),
+    DEVICE_BIND_PROHIBIT(500621, "绑定失败，设备已有父级设备"),
+    DEVICE_BIND_PROHIBIT_GATEWAY(500622, "绑定失败，设备不存在或不是网关子设备"),
+    DEVICE_UNBIND_ERROR(500623, "设备解绑失败"),
+    DEVICE_EXPORT_ERROR(500624, "设备导出失败"),
+    DEVICE_EXPORT_ERROR_NULL(500625, "设备导出失败，数据为空"),
+    DEVICE_IMPORT_ERROR(500626, "设备导入失败"),
+    DEVICE_IMPORT_ERROR_CSV(500627, "设备导入失败,csv解析失败"),
+
+    DEVICE_REMOTE_CONFIG_JSON_ERROR(500628, "请检查数据格式，非标准json格式"),
+
+    DEVICE_REMOTE_CONFIG_PUSH_FAILED(500629, "远程配置推送失败"),
+    DEVICE_DASHBOARD_NAME_REPEAT(500629, "设备看板名称重复"),
+    DEVICE_DASHBOARD_COMPONENT_NAME_REPEAT(500629, "设备看板组件名称重复"),
+    DEVICE_DASHBOARD_DELETE_NOT_DATA(500629, "删除数据不存在"),
+
+    /**
+     * 组织
+     */
+    ORGANIZATION_ERROR(500630, "组织未知错误"),
+    // 根据id
+    ORGANIZATION_QUERY_ERROR(500631, "查询组织信息失败"),
+    ORGANIZATION_SAVE_ERROR(500632, "新增组织失败"),
+    // 在某个组织下
+    ORGANIZATION_EXIST_ERROR(500633, "组织已存在"),
+    ORGANIZATION_DELETE_ERROR(500634, "删除组织失败"),
+    ORGANIZATION_UPDATE_ERROR(500635, "修改组织失败"),
+    ORGANIZATION_DELETE_PROHIBIT_DEVICE(500636, "删除失败，组织下存在设备"),
+    ORGANIZATION_DELETE_PROHIBIT_CHILD(500637, "删除失败，组织下存在子组织"),
+
+    /**
+     * 设备升级
+     */
+    PARTUPGRADE_ERROR(500640, "固件升级未知错误"),
+    PARTUPGRADE_QUERY_ERROR(500641, "查询设备升级信息失败"),
+    PARTUPGRADE_SAVE_ERROR(500642, "新增设备升级失败"),
+    // 在某个产品下
+    PARTUPGRADE_EXIST_ERROR(500643, "设备升级名称已存在"),
+    PARTUPGRADE_DELETE_ERROR(500644, "删除设备升级失败"),
+    PARTUPGRADE_DELETE_PROHIBIT(500645, "删除失败，存在子任务"),
+    PARTUPGRADE_UPDATE_ERROR(500646, "修改设备升级失败"),
+
+    /**
+     * 升级任务
+     */
+    UPGRADETASK_ERROR(500640, "升级任务未知错误"),
+    UPGRADETASK_QUERY_ERROR(500641, "查询升级任务信息失败"),
+    UPGRADETASK_SAVE_ERROR(500642, "新增升级任务失败"),
+    // 在某个升级下
+    UPGRADETASK_EXIST_ERROR(500643, "升级任务名称已存在"),
+    UPGRADETASK_DELETE_ERROR(500644, "删除升级任务失败"),
+    UPGRADETASK_DELETE_PROHIBIT(500645, "删除失败，任务正在进行中"),
+    UPGRADETASK_UPDATE_ERROR(500646, "修改升级任务失败"),
+    UPGRADETASK_VERSION_ERROR(500647, "设备版本信息不存在"),
+    UPGRADETASK_STATUS_ERROR(500648, "升级状态异常"),
+
+
+    /**
+     * 升级记录
+     */
+    UPGRADERECORD_ERROR(500640, "升级记录未知错误"),
+    UPGRADERECORD_QUERY_ERROR(500641, "查询升级记录失败"),
+    UPGRADERECORD_SAVE_ERROR(500642, "新增升级记录失败"),
+    // 在某个任务下
+    UPGRADERECORD_EXIST_ERROR(500643, "升级记录已存在"),
+
+
+    //在线调试设备
+    ONLINE_DEVICE_ATTRIBUTE_SUCCESS(500500, "下发指令成功"),
+    ONLINE_DEVICE_ATTRIBUTE_ERROR(500501, "下发指令失败"),
+    ONLINE_DEVICE_INACTIVE_ERROR(500501, "设备未激活"),
+
+
+    //topic
+    MESSAGE_TOPIC_ERROR_EXIT(500700, "Topic已存在"),
+    MESSAGE_TOPIC_START_ERROR(500701, "Topic启用失败"),
+    MESSAGE_TOPIC_STOP_ERROR(500702, "Topic禁用失败"),
+    MESSAGE_TOPIC_PUBLISHER_NOT_EXITED(500703, "发布者用户名称不存在"),
+    MESSAGE_TOPIC_PUBLISHER_IS_NULL(500704, "发布者用户名称为空"),
+    MESSAGE_TOPIC_DELETE_ERROR(500705, "Topic删除失败"),
+    MESSAGE_TOPIC_ERROR_NOT_EXIT(500706, "Topic不存在"),
+    MESSAGE_TOPIC_TOKEN_SUCCESS(500707, "Topic校验成功"),
+    MESSAGE_TOPIC_TOKEN_FAILED(500708, "Topic校验失败"),
+
+
+    //设备模拟器
+    DEVICE_SIMULATION_START_ERROR(500750, "设备模拟器启动失败"),
+    DEVICE_SIMULATION_NOT_FOUND(500751, "未找到绑定设备"),
+    DEVICE_SIMULATION_IS_STARTED(500752, "模拟器已启动"),
+    DEVICE_SIMULATION_IS_NOT_STARTED(500753, "模拟器未启动"),
+    DEVICE_SIMULATION_MSG_SEND_FAILED(500754, "消息发送失败"),
+    DEVICE_SIMULATION_STOP_ERROR(500755, "设备模拟器停止失败"),
+    DEVICE_SIMULATION_JOB_START_ERROR(500756, "模拟器定时任务开启失败"),
+    DEVICE_SIMULATION_JOB_START_SUCCESS(500757, "策略推送开启成功"),
+
+    //http设备推送
+    HTTP_DEVICE_MSG_PUSH(510001, "消息格式有误"),
+
+    //视频
+    VIDEO_AI_DEVICEID_NAME_EMPTY(600100, "设备编码为空"),
+
+    VIDEO_AI_DEVICE_EXITS(600101, "该设备已配置"),
+
+    VIDEO_AI_ANALYSE_ON_EXITING(600102, "AI分析中，禁止删除任务"),
+
+    VIDEO_AI_EDIT_ID_NOT_EXITED(600103, "任务编辑，不可缺少Id"),
+
+    VIDEO_AI_ID_NOT_MATCH_DEVICEID(600104, "任务Id和设备Id不匹配"),
+
+    VIDEO_AI_SUBTASK_ON_EXITING(600105, "存在分析中的子任务，不可更改"),
+
+    VIDEO_AI_SUBTASK_ON_DELETE(600106, "任务分析中不可删除"),
+
+    VIDEO_AI_NOT_SUPPORTED(600107, "暂不支持的协议设备"),
+
+    VIDEO_AI_START_FAILED(600108, "分析任务启动失败"),
+
+    VIDEO_DEVICE_NOT_CONFIG(600109, "视频设备未配置"),
+
+    VIDEO_DEVICE_ID_EXITED(600110, "设备ID已绑定"),
+    VIDEO_DEVICE_TASK_ERROR(600111, "视频AI分析服务调用失败，无法创建分析任务"),
+    VIDEO_DEVICE_NOT_CONFIG_RTSP(600112, "未配置视频地址"),
+    VIDEO_DEVICE_PROXY_FAILED(600113, "代理创建失败"),
+    VIDEO_DEVICE_PROXY_START_FAILED(600114, "代理开启失败"),
+
+    //应用市场 边缘主机
+    EDGE_GATEWAY_FILE_PATH_NOT_EXITED(600198, "文件不存在"),
+    EDGE_GATEWAY_FILE_PATH_ERROR(600199, "文件路径错误"),
+
+    APP_MARKET_CODE_EXITED(600200, "应用编码已存在"),
+
+    APP_MARKET_ID_NOT_EXITED(600201, "无应用Id，无法更新"),
+
+    APP_MARKET_FILE_DELETE_FAILED(600202, "文件删除失败"),
+
+    EDGE_APP_BIND_ERROR_EXITED(600203, "应用已存在"),
+
+    EDGE_APP_UNBIND_ERROR_UNINSTALL(600208, "应用未卸载"),
+
+    APP_MARKET_IMPORT_LACK_FILE(600204, "应用导入缺少必要文件"),
+
+    APP_MARKET_IMPORT_FAILED(600204, "应用导入失败"),
+
+    APP_BIND_SCRIPT_EXITED(600205, "应用脚本已绑定"),
+
+    APP_MARKET_ISENABLE(600206, "应用已启用"),
+
+    SCRIPT_ISENABLE(600207, "脚本已启用"),
+
+    // 500_100
+    // 500_200
+
+    // 500_300  规则引擎
+    RULE_ERROR(500300, "规则引擎未知错误"),
+
+    RULE_INSTANCE_QUERY_ERROR(500310, "查询规则实例失败"),
+
+    RULE_INSTANCE_NOT_EXIST(500310, "规则实例不存在"),
+
+    RULE_INSTANCE_SAVE_ERROR(500320, "新增规则实例失败"),
+
+    RULE_INSTANCE_EXIST_ERROR(500321, "规则实例名称已存在"),
+
+    RULE_INSTANCE_UPDATE_ERROR(500330, "修改规则实例失败"),
+
+    RULE_INSTANCE_DELETE_ERROR(500340, "删除规则实例失败"),
+
+    RULE_INSTANCE_START_ERROR(500350, "启动规则实例失败，请检查组件参数"),
+
+    RULE_INSTANCE_STOP_ERROR(500360, "停止规则实例失败"),
+
+    RULE_INSTANCE_PRODUCT_NOT_CHOICE_ERROR(500360, "请先选择产品！"),
+
+    RULE_INSTANCE_NOT_MULTIPLE_ROOT_NODE(500361, "根节点异常！"),
+
+    RULE_CRON_EXPRESSION_ERROR(500362, "cron 表达式错误！"),
+
+    RULE_RULE_ALARM_NOT_RELATION_ERROR(500363, "告警规则没有关联！"),
+
+    RULE_ENGINE_NOT_INSTANCE_ERROR(500364, "规则引擎没有实例部署！"),
+
+    RULE_THRESHOLD_EXCEL_UPLOAD_REPEAT(500365, "阈值管理分类名重复！"),
+
+    RULE_THRESHOLD_EXCEL_TEMPLATE_INCORRECT(500366, "阈值管理模板不正确！"),
+
+    RULE_THRESHOLD_NOT_EXIST(500367, "阈值管理分类不存在！"),
+
+
+    // 500_400  管道元素相关
+    SP_ERROR(500400, "管道未知错误"),
+
+    SP_ADAPTER(500410, "适配器异常"),
+
+    SP_ELEMENT_NOTFOUND(500411, "没有发现元素异常"),
+
+    SP_NO_MATCHING_FORMAT(500412, "格式不匹配异常"),
+
+    SP_NO_MATCHING_JSON_SCHEMA(500413, "JSON格式不匹配异常"),
+
+    SP_NO_MATCHING_PROTOCOL(500414, "协议不匹配异常"),
+
+    SP_NO_MATCHING_SCHEMA(500415, "模式不匹配异常"),
+
+    SP_NO_SEPA_IN_PIPELINE(500416, "管道中没有元素异常"),
+
+    SP_NO_SUITABLE_SEPAS_AVAILABLE(500417, "没有合适的元素可用异常"),
+
+    SP_PARSE(500418, "解析异常"),
+
+    SP_REMOTE_SERVER_NOT_ACCESSIBLE(500419, "无法访问远程服务器"),
+
+    SP_SEPA_PARSE(500420, "元素解析异常"),
+
+    SP_RUNTIME(500421, "运行时异常"),
+
+    SP_NO_RUNTIME_DATA(500422, "无法获取运行时数据"),
+
+    SP_QUERY_ERROR(500423, "查询设备信息失败"),
+
+    SP_URIOFFLINE_ERROR(500424, "URI不可用,无法检索内容"),
+
+    SP_NOSEPAFORMAT_ERROR(500425, "错误的格式,无法识别实体"),
+
+    SP_STORAGE_ERROR(500426, "存储错误"),
+
+    SP_NO_VALID_CONNECTION(500427, "不是有效的连接,预期的输入事件类型与计算输出类型不匹配"),
+
+    SP_NO_SEPA_FOUND(500428, "没有找到任何元素匹配这个元素的输出"),
+
+    SP_NO_MATCHING_FORMAT_CONNECTION(500429, "不是一个有效的连接，没有支持的输入格式匹配产生的输出格式"),
+
+    SP_NO_MATCHING_PROTOCOL_CONNECTION(500430, "不是一个有效的连接，没有支持的输入协议匹配提供的输出协议"),
+
+    SP_NO_MATCHING_SCHEME(500431, "来自服务器的JSON是无效的，元素描述中的键不映射JSON响应中的键"),
+
+    SP_PARSE_ERROR(500432, "无法解析元素描述"),
+
+    SP_WARNING_NO_ICON(500433, "图标缺失"),
+
+    SP_WARNING_NO_NAME(500434, "名称缺失"),
+
+    SP_WARNING_NO_LABEL(500435, "描述缺失"),
+
+    SP_NOT_REMOVED(500436, "无法删除元素"),
+
+    SP_INVALID_CONNECTION(500437, "无效连接"),
+
+    SP_USER_NOT_FOUND(500438, "未找到用户"),
+
+    /**
+     * operation 500800 运维管理平台状态码
+     */
+    OP_NOTIFY_TEMPLATE_NAME_EXIST(500801, "通知模板名重复"),
+
+    OP_NOTIFY_TEMPLATE_NOT_EXIST(500802, "通知模板不存在"),
+
+    OP_USER_PROHIBIT(500803, "此用户被禁用，无法登录"),
+
+    OP_USER_AUTHENTICATION_FAIL(500804, "用户名或密码错误"),
+
+    OP_TYPE_NOTNULL(500805, "参数type不能为空"),
+
+    OP_TEMPLATE_ID_NOTNULL(500806, "参数templateId不能为空"),
+
+    OP_TEMPLATE_TYPE_NOT_EMAIL(500807, "模板类型不是邮件"),
+
+    OP_ADMIN_NOT_AUDIT(500808, "管理员未审核，请联系超级管理员审核"),
+
+    OP_ADMIN_AUDIT_FAIL(500809, "管理员审核不通过，请联系超级管理员审核"),
+
+    OP_DATETIME_PARSE_EXCEPTION(500810, "日期格式化异常"),
+
+    OP_USER_MANAGER_EMAIL_EXIST(500811, "邮箱不能重复"),
+
+    OP_USER_MANAGER_MOBILE_EXIST(500812, "手机号不能重复"),
+
+    OP_KEYCLOAK_USER_NOT_EXIST(500813, "keycloak未绑定账号"),
+
+    OP_DATE_PARSE_FAIL(500814, "日期解析失败"),
+
+    OP_TASK_JOB_NAME_REPEAT(500815, "任务名不能重复"),
+
+    OP_TASK_JOB_NAME_NOT_UPDATE(500816, "任务名不能修改"),
+
+    OP_TASK_JOB_STATUS_TRUE_NOT_UPDATE(500817, "任务启动中，不能修改任务"),
+
+    OP_TASK_JOB_STATUS_TRUE(500818, "任务启动中，不需要启动"),
+
+    OP_TASK_JOB_STATUS_FALSE(500819, "任务已关闭，不需要关闭"),
+
+    OP_TASK_JOB_NOT_EXIST(500820, "任务不存在"),
+
+    OP_LOG_DUMP_OPERATION_HBASE_NOT_EXIST(500821, "操作日志不存hbase"),
+
+    OP_LOG_DUMP_LOGIN_HBASE_NOT_EXIST(500822, "登录日志不存hbase"),
+
+    OP_LOG_DUMP_SYSTEM_HBASE_NOT_EXIST(500823, "系统日志不存hbase"),
+
+    OP_LOG_DUMP_CSV_FAIL(500824, "csv导出异常"),
+
+    OP_LOG_DUMP_DATA_NULL(500825, "日志为空，不需要转储"),
+
+    OP_TASK_JOB_STATUS_TRUE_CLOSE_FAILED(500826, "任务启动中，删除任务失败"),
+
+    OP_TENANT_USER_GROUP_REPEAT(500827, "租户用户组重复"),
+
+    OP_USER_EXISTS_IN_TENANT_USER_GROUP(500828, "用户在用户组中存在，删除失败"),
+
+    OP_SEND_EMAIL_NO_USER_EXCEPTION(500829, "发送邮件，没有用户，不能发送"),
+
+    OP_ALARM_RULE_EXIST_TEMPLATE_ID(500830, "告警规则表使用此模板，不能删除"),
+
+    OP_NOTIFY_CONFIG_NAME_EXIST(500831, "通知配置名重复"),
+
+    OP_TEMPLATE_STRING_REPLACE_FAIL(500832, "模板字符串替换失败,map的key必须存在于模板字符串中"),
+
+    OP_TEMPLATE_STRING_REPLACE2_FAIL(500833, "模板字符串替换失败,map不能为空"),
+
+    OP_TEMPLATE_STRING_REPLACE3_FAIL(500834, "模板字符串替换失败,模板字符串不能为空"),
+
+    OP_EMAIL_SEND_FAIL(500835, "邮箱发送失败，30s后自动重试"),
+
+    OP_SMS_SEND_SYSTEM_FAIL(500836, "短信发送失败，系统异常"),
+
+    OP_EXTERNAL_CONTACTS_USERNAME_REPEAT(500837, "用户名已存在，保存失败"),
+
+    OP_EXTERNAL_CONTACTS_EMAIL_REPEAT(500838, "邮箱已存在，保存失败"),
+
+    OP_EXTERNAL_CONTACTS_MOBILE_REPEAT(500839, "手机号已存在，保存失败"),
+
+    OP_CONTACTS_GROUP_IN_USE_BY_NOTIFY_TEMPLATE(500839, "通讯组被通知模板使用，不能删除"),
+
+    OP_NOTIFY_CONFIG_NOT_EXIST(500840, "通知配置不存在"),
+
+
+    //删除枚举
+    UN_DEL(0, "未删除"),
+    IS_DEL(1, "删除"),
+
+    //状态枚举
+    STATE_OPEN(2, "开启"),
+    STATE_CLOSE(1, "停用"),
+
+    /**
+     * operation 500900 面板
+     */
+    PANEL_ERROR(500900, "面板未知错误"),
+    PANEL_QUERY_ERROR(500901, "查询面板信息失败"),
+    PANEL_EXIST_ERROR(500902, "面板名称已存在"),
+    PANEL_NOT_EXIST_ERROR(500903, "无此面板信息"),
+    PANEL_DELETE_ERROR(500904, "删除面板失败"),
+    PANEL_UPDATE_ERROR(500905, "更新面板失败"),
+    PANEL_PROHIBIT_ERROR(500906, "停用面板失败"),
+    PANEL_RECOVERY_ERROR(500907, "发布面板失败"),
+    PANEL_START_ERROR(500908, "协议已启动,不可修改、删除"),
+
+    /**
+     * operation 600100 APP家庭
+     */
+    SCENE_NAME_REPEAR(600100, "场景名称重复"),
+    SHARE_CODE_ERROR(600200, "邀请码错误"),
+    SHARE_USER_EXIST(600201, "该用户已分享，请勿重复分享"),
+
+    // 200_400  管道元素相关
+    SP_SUCCESS(200400, "SP相关操作成功"),
+
+    SP_STORAGE_SUCCESS(200410, "实体成功存储"),
+
+    SP_OPERATION_SUCCESS(200411, "操作成功"),
+
+    SP_PIPELINE_DELETED(200412, "管道删除成功"),
+
+    SP_PIPELINE_MODIFIED(200413, "管道修改成功");
+
+    private Integer code;
+
+    private String msg;
+
+    private AppResponseEnum(Integer code, String msg) {
+        this.code = code;
+        this.msg = msg;
+    }
+
+
+    private static final Map<Integer, AppResponseEnum> LOOKUP_CODE = new HashMap<>();
+
+    private static final Map<String, AppResponseEnum> LOOKUP_MSG = new HashMap<>();
+
+    static {
+        for (AppResponseEnum e : EnumSet.allOf(AppResponseEnum.class)) {
+            LOOKUP_CODE.put(e.code, e);
+            LOOKUP_MSG.put(e.msg, e);
+        }
+    }
+
+
+    public static AppResponseEnum find(Integer code, AppResponseEnum defaultValue) {
+        AppResponseEnum value = LOOKUP_CODE.get(code);
+        if (value == null) {
+            return defaultValue;
+        }
+        return value;
+    }
+
+    public static AppResponseEnum find(String msg, AppResponseEnum defaultValue) {
+        AppResponseEnum value = LOOKUP_MSG.get(msg);
+        if (value == null) {
+            return defaultValue;
+        }
+        return value;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getMsg() {
+        return msg;
+    }
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/config/SecurityConfig.java

@@ -111,7 +111,7 @@ public class SecurityConfig
             .authorizeHttpRequests((requests) -> {
                 permitAllUrl.getUrls().forEach(url -> requests.antMatchers(url).permitAll());
                 // 对于登录login 注册register 验证码captchaImage 允许匿名访问
-                requests.antMatchers("/login", "/register", "/captchaImage").permitAll()
+                requests.antMatchers("/login", "/register", "/captchaImage").permitAll().antMatchers("/ws/**","/w-stomp/**","/w-topic/**", "/websocket/**").permitAll()
                     // 静态资源，可匿名访问
                     .antMatchers(HttpMethod.GET, "/", "/*.html", "/**/*.html", "/**/*.css", "/**/*.js", "/profile/**").permitAll()
                     .antMatchers("/swagger-ui.html", "/swagger-resources/**", "/webjars/**", "/*/api-docs", "/druid/**").permitAll()

ruoyi-ui/Dockerfile

@@ -0,0 +1,15 @@
+# 基础镜像
+FROM nginx
+# author
+MAINTAINER ruoyi
+
+# 挂载目录
+VOLUME /home/ruoyi/projects/ruoyi-ui
+# 创建目录
+RUN mkdir -p /home/ruoyi/projects/ruoyi-ui
+# 指定路径
+WORKDIR /home/ruoyi/projects/ruoyi-ui
+# 复制conf文件到路径
+COPY ./docker/conf/nginx.conf /etc/nginx/nginx.conf
+# 复制html文件到路径
+COPY ./dist /home/ruoyi/projects/ruoyi-ui

ruoyi-ui/package.json

@@ -45,6 +45,7 @@
     "axios": "0.28.1",
     "clipboard": "2.0.8",
     "core-js": "3.37.1",
+    "crypto": "^1.0.1",
     "dayjs": "^1.11.13",
     "echarts": "5.4.0",
     "element-ui": "2.15.14",

ruoyi-ui/public/ZLMRTCClient.js

@@ -0,0 +1,7736 @@
+const ZLMRTCClient = (function (exports) {
+  'use strict';
+
+  const Events$1 = {
+    WEBRTC_NOT_SUPPORT: 'WEBRTC_NOT_SUPPORT',
+    WEBRTC_ICE_CANDIDATE_ERROR: 'WEBRTC_ICE_CANDIDATE_ERROR',
+    WEBRTC_OFFER_ANWSER_EXCHANGE_FAILED: 'WEBRTC_OFFER_ANWSER_EXCHANGE_FAILED',
+    WEBRTC_ON_REMOTE_STREAMS: 'WEBRTC_ON_REMOTE_STREAMS',
+    WEBRTC_ON_LOCAL_STREAM: 'WEBRTC_ON_LOCAL_STREAM',
+    WEBRTC_ON_CONNECTION_STATE_CHANGE: 'WEBRTC_ON_CONNECTION_STATE_CHANGE',
+    WEBRTC_ON_DATA_CHANNEL_OPEN: 'WEBRTC_ON_DATA_CHANNEL_OPEN',
+    WEBRTC_ON_DATA_CHANNEL_CLOSE: 'WEBRTC_ON_DATA_CHANNEL_CLOSE',
+    WEBRTC_ON_DATA_CHANNEL_ERR: 'WEBRTC_ON_DATA_CHANNEL_ERR',
+    WEBRTC_ON_DATA_CHANNEL_MSG: 'WEBRTC_ON_DATA_CHANNEL_MSG',
+    CAPTURE_STREAM_FAILED: 'CAPTURE_STREAM_FAILED'
+  };
+
+  const VERSION = '1.0.1';
+  const BUILD_DATE = 'Thu Mar 24 2022 17:42:57 GMT+0800 (China Standard Time)';
+
+  // Copyright (C) <2018> Intel Corporation
+  //
+  // SPDX-License-Identifier: Apache-2.0
+  // eslint-disable-next-line require-jsdoc
+  function isFirefox() {
+    return window.navigator.userAgent.match('Firefox') !== null;
+  } // eslint-disable-next-line require-jsdoc
+
+  function isChrome() {
+    return window.navigator.userAgent.match('Chrome') !== null;
+  } // eslint-disable-next-line require-jsdoc
+
+  function isEdge() {
+    return window.navigator.userAgent.match(/Edge\/(\d+).(\d+)$/) !== null;
+  } // eslint-disable-next-line require-jsdoc
+
+  // Copyright (C) <2018> Intel Corporation
+  /**
+   * @class AudioSourceInfo
+   * @classDesc Source info about an audio track. Values: 'mic', 'screen-cast', 'file', 'mixed'.
+   * @memberOf Owt.Base
+   * @readonly
+   * @enum {string}
+   */
+
+  const AudioSourceInfo = {
+    MIC: 'mic',
+    SCREENCAST: 'screen-cast',
+    FILE: 'file',
+    MIXED: 'mixed'
+  };
+  /**
+   * @class VideoSourceInfo
+   * @classDesc Source info about a video track. Values: 'camera', 'screen-cast', 'file', 'mixed'.
+   * @memberOf Owt.Base
+   * @readonly
+   * @enum {string}
+   */
+
+  const VideoSourceInfo = {
+    CAMERA: 'camera',
+    SCREENCAST: 'screen-cast',
+    FILE: 'file',
+    MIXED: 'mixed'
+  };
+  /**
+   * @class TrackKind
+   * @classDesc Kind of a track. Values: 'audio' for audio track, 'video' for video track, 'av' for both audio and video tracks.
+   * @memberOf Owt.Base
+   * @readonly
+   * @enum {string}
+   */
+
+  const TrackKind = {
+    /**
+     * Audio tracks.
+     * @type string
+     */
+    AUDIO: 'audio',
+
+    /**
+     * Video tracks.
+     * @type string
+     */
+    VIDEO: 'video',
+
+    /**
+     * Both audio and video tracks.
+     * @type string
+     */
+    AUDIO_AND_VIDEO: 'av'
+  };
+
+  /**
+   * @class Resolution
+   * @memberOf Owt.Base
+   * @classDesc The Resolution defines the size of a rectangle.
+   * @constructor
+   * @param {number} width
+   * @param {number} height
+   */
+
+  class Resolution {
+    // eslint-disable-next-line require-jsdoc
+    constructor(width, height) {
+      /**
+       * @member {number} width
+       * @instance
+       * @memberof Owt.Base.Resolution
+       */
+      this.width = width;
+      /**
+       * @member {number} height
+       * @instance
+       * @memberof Owt.Base.Resolution
+       */
+
+      this.height = height;
+    }
+
+  }
+
+  /*
+	 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  let logDisabled_ = true;
+  let deprecationWarnings_ = true;
+
+  /**
+   * Extract browser version out of the provided user agent string.
+   *
+   * @param {!string} uastring userAgent string.
+   * @param {!string} expr Regular expression used as match criteria.
+   * @param {!number} pos position in the version string to be returned.
+   * @return {!number} browser version.
+   */
+  function extractVersion(uastring, expr, pos) {
+    const match = uastring.match(expr);
+    return match && match.length >= pos && parseInt(match[pos], 10);
+  }
+
+  // Wraps the peerconnection event eventNameToWrap in a function
+  // which returns the modified event object (or false to prevent
+  // the event).
+  function wrapPeerConnectionEvent(window, eventNameToWrap, wrapper) {
+    if (!window.RTCPeerConnection) {
+      return;
+    }
+    const proto = window.RTCPeerConnection.prototype;
+    const nativeAddEventListener = proto.addEventListener;
+    proto.addEventListener = function (nativeEventName, cb) {
+      if (nativeEventName !== eventNameToWrap) {
+        return nativeAddEventListener.apply(this, arguments);
+      }
+      const wrappedCallback = (e) => {
+        const modifiedEvent = wrapper(e);
+        if (modifiedEvent) {
+          if (cb.handleEvent) {
+            cb.handleEvent(modifiedEvent);
+          } else {
+            cb(modifiedEvent);
+          }
+        }
+      };
+      this._eventMap = this._eventMap || {};
+      if (!this._eventMap[eventNameToWrap]) {
+        this._eventMap[eventNameToWrap] = new Map();
+      }
+      this._eventMap[eventNameToWrap].set(cb, wrappedCallback);
+      return nativeAddEventListener.apply(this, [nativeEventName,
+        wrappedCallback]);
+    };
+
+    const nativeRemoveEventListener = proto.removeEventListener;
+    proto.removeEventListener = function (nativeEventName, cb) {
+      if (nativeEventName !== eventNameToWrap || !this._eventMap
+        || !this._eventMap[eventNameToWrap]) {
+        return nativeRemoveEventListener.apply(this, arguments);
+      }
+      if (!this._eventMap[eventNameToWrap].has(cb)) {
+        return nativeRemoveEventListener.apply(this, arguments);
+      }
+      const unwrappedCb = this._eventMap[eventNameToWrap].get(cb);
+      this._eventMap[eventNameToWrap].delete(cb);
+      if (this._eventMap[eventNameToWrap].size === 0) {
+        delete this._eventMap[eventNameToWrap];
+      }
+      if (Object.keys(this._eventMap).length === 0) {
+        delete this._eventMap;
+      }
+      return nativeRemoveEventListener.apply(this, [nativeEventName,
+        unwrappedCb]);
+    };
+
+    Object.defineProperty(proto, 'on' + eventNameToWrap, {
+      get() {
+        return this['_on' + eventNameToWrap];
+      },
+      set(cb) {
+        if (this['_on' + eventNameToWrap]) {
+          this.removeEventListener(eventNameToWrap,
+            this['_on' + eventNameToWrap]);
+          delete this['_on' + eventNameToWrap];
+        }
+        if (cb) {
+          this.addEventListener(eventNameToWrap,
+            this['_on' + eventNameToWrap] = cb);
+        }
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+
+  function disableLog(bool) {
+    if (typeof bool !== 'boolean') {
+      return new Error('Argument type: ' + typeof bool +
+        '. Please use a boolean.');
+    }
+    logDisabled_ = bool;
+    return (bool) ? 'adapter.js logging disabled' :
+      'adapter.js logging enabled';
+  }
+
+  /**
+   * Disable or enable deprecation warnings
+   * @param {!boolean} bool set to true to disable warnings.
+   */
+  function disableWarnings(bool) {
+    if (typeof bool !== 'boolean') {
+      return new Error('Argument type: ' + typeof bool +
+        '. Please use a boolean.');
+    }
+    deprecationWarnings_ = !bool;
+    return 'adapter.js deprecation warnings ' + (bool ? 'disabled' : 'enabled');
+  }
+
+  function log$1() {
+    if (typeof window === 'object') {
+      if (logDisabled_) {
+        return;
+      }
+      if (typeof console !== 'undefined' && typeof console.log === 'function') {
+        console.log.apply(console, arguments);
+      }
+    }
+  }
+
+  /**
+   * Shows a deprecation warning suggesting the modern and spec-compatible API.
+   */
+  function deprecated(oldMethod, newMethod) {
+    if (!deprecationWarnings_) {
+      return;
+    }
+    console.warn(oldMethod + ' is deprecated, please use ' + newMethod +
+      ' instead.');
+  }
+
+  /**
+   * Browser detector.
+   *
+   * @return {object} result containing browser and version
+   *     properties.
+   */
+  function detectBrowser(window) {
+    // Returned result object.
+    const result = {browser: null, version: null};
+
+    // Fail early if it's not a browser
+    if (typeof window === 'undefined' || !window.navigator) {
+      result.browser = 'Not a browser.';
+      return result;
+    }
+
+    const {navigator} = window;
+
+    if (navigator.mozGetUserMedia) { // Firefox.
+      result.browser = 'firefox';
+      result.version = extractVersion(navigator.userAgent,
+        /Firefox\/(\d+)\./, 1);
+    } else if (navigator.webkitGetUserMedia ||
+      (window.isSecureContext === false && window.webkitRTCPeerConnection &&
+        !window.RTCIceGatherer)) {
+      // Chrome, Chromium, Webview, Opera.
+      // Version matches Chrome/WebRTC version.
+      // Chrome 74 removed webkitGetUserMedia on http as well so we need the
+      // more complicated fallback to webkitRTCPeerConnection.
+      result.browser = 'chrome';
+      result.version = extractVersion(navigator.userAgent,
+        /Chrom(e|ium)\/(\d+)\./, 2);
+    } else if (navigator.mediaDevices &&
+      navigator.userAgent.match(/Edge\/(\d+).(\d+)$/)) { // Edge.
+      result.browser = 'edge';
+      result.version = extractVersion(navigator.userAgent,
+        /Edge\/(\d+).(\d+)$/, 2);
+    } else if (window.RTCPeerConnection &&
+      navigator.userAgent.match(/AppleWebKit\/(\d+)\./)) { // Safari.
+      result.browser = 'safari';
+      result.version = extractVersion(navigator.userAgent,
+        /AppleWebKit\/(\d+)\./, 1);
+      result.supportsUnifiedPlan = window.RTCRtpTransceiver &&
+        'currentDirection' in window.RTCRtpTransceiver.prototype;
+    } else { // Default fallthrough: not supported.
+      result.browser = 'Not a supported browser.';
+      return result;
+    }
+
+    return result;
+  }
+
+  /**
+   * Checks if something is an object.
+   *
+   * @param {*} val The something you want to check.
+   * @return true if val is an object, false otherwise.
+   */
+  function isObject$1(val) {
+    return Object.prototype.toString.call(val) === '[object Object]';
+  }
+
+  /**
+   * Remove all empty objects and undefined values
+   * from a nested object -- an enhanced and vanilla version
+   * of Lodash's `compact`.
+   */
+  function compactObject(data) {
+    if (!isObject$1(data)) {
+      return data;
+    }
+
+    return Object.keys(data).reduce(function (accumulator, key) {
+      const isObj = isObject$1(data[key]);
+      const value = isObj ? compactObject(data[key]) : data[key];
+      const isEmptyObject = isObj && !Object.keys(value).length;
+      if (value === undefined || isEmptyObject) {
+        return accumulator;
+      }
+      return Object.assign(accumulator, {[key]: value});
+    }, {});
+  }
+
+  /* iterates the stats graph recursively. */
+  function walkStats(stats, base, resultSet) {
+    if (!base || resultSet.has(base.id)) {
+      return;
+    }
+    resultSet.set(base.id, base);
+    Object.keys(base).forEach(name => {
+      if (name.endsWith('Id')) {
+        walkStats(stats, stats.get(base[name]), resultSet);
+      } else if (name.endsWith('Ids')) {
+        base[name].forEach(id => {
+          walkStats(stats, stats.get(id), resultSet);
+        });
+      }
+    });
+  }
+
+  /* filter getStats for a sender/receiver track. */
+  function filterStats(result, track, outbound) {
+    const streamStatsType = outbound ? 'outbound-rtp' : 'inbound-rtp';
+    const filteredResult = new Map();
+    if (track === null) {
+      return filteredResult;
+    }
+    const trackStats = [];
+    result.forEach(value => {
+      if (value.type === 'track' &&
+        value.trackIdentifier === track.id) {
+        trackStats.push(value);
+      }
+    });
+    trackStats.forEach(trackStat => {
+      result.forEach(stats => {
+        if (stats.type === streamStatsType && stats.trackId === trackStat.id) {
+          walkStats(result, stats, filteredResult);
+        }
+      });
+    });
+    return filteredResult;
+  }
+
+  /*
+	 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+  const logging = log$1;
+
+  function shimGetUserMedia$3(window, browserDetails) {
+    const navigator = window && window.navigator;
+
+    if (!navigator.mediaDevices) {
+      return;
+    }
+
+    const constraintsToChrome_ = function (c) {
+      if (typeof c !== 'object' || c.mandatory || c.optional) {
+        return c;
+      }
+      const cc = {};
+      Object.keys(c).forEach(key => {
+        if (key === 'require' || key === 'advanced' || key === 'mediaSource') {
+          return;
+        }
+        const r = (typeof c[key] === 'object') ? c[key] : {ideal: c[key]};
+        if (r.exact !== undefined && typeof r.exact === 'number') {
+          r.min = r.max = r.exact;
+        }
+        const oldname_ = function (prefix, name) {
+          if (prefix) {
+            return prefix + name.charAt(0).toUpperCase() + name.slice(1);
+          }
+          return (name === 'deviceId') ? 'sourceId' : name;
+        };
+        if (r.ideal !== undefined) {
+          cc.optional = cc.optional || [];
+          let oc = {};
+          if (typeof r.ideal === 'number') {
+            oc[oldname_('min', key)] = r.ideal;
+            cc.optional.push(oc);
+            oc = {};
+            oc[oldname_('max', key)] = r.ideal;
+            cc.optional.push(oc);
+          } else {
+            oc[oldname_('', key)] = r.ideal;
+            cc.optional.push(oc);
+          }
+        }
+        if (r.exact !== undefined && typeof r.exact !== 'number') {
+          cc.mandatory = cc.mandatory || {};
+          cc.mandatory[oldname_('', key)] = r.exact;
+        } else {
+          ['min', 'max'].forEach(mix => {
+            if (r[mix] !== undefined) {
+              cc.mandatory = cc.mandatory || {};
+              cc.mandatory[oldname_(mix, key)] = r[mix];
+            }
+          });
+        }
+      });
+      if (c.advanced) {
+        cc.optional = (cc.optional || []).concat(c.advanced);
+      }
+      return cc;
+    };
+
+    const shimConstraints_ = function (constraints, func) {
+      if (browserDetails.version >= 61) {
+        return func(constraints);
+      }
+      constraints = JSON.parse(JSON.stringify(constraints));
+      if (constraints && typeof constraints.audio === 'object') {
+        const remap = function (obj, a, b) {
+          if (a in obj && !(b in obj)) {
+            obj[b] = obj[a];
+            delete obj[a];
+          }
+        };
+        constraints = JSON.parse(JSON.stringify(constraints));
+        remap(constraints.audio, 'autoGainControl', 'googAutoGainControl');
+        remap(constraints.audio, 'noiseSuppression', 'googNoiseSuppression');
+        constraints.audio = constraintsToChrome_(constraints.audio);
+      }
+      if (constraints && typeof constraints.video === 'object') {
+        // Shim facingMode for mobile & surface pro.
+        let face = constraints.video.facingMode;
+        face = face && ((typeof face === 'object') ? face : {ideal: face});
+        const getSupportedFacingModeLies = browserDetails.version < 66;
+
+        if ((face && (face.exact === 'user' || face.exact === 'environment' ||
+          face.ideal === 'user' || face.ideal === 'environment')) &&
+          !(navigator.mediaDevices.getSupportedConstraints &&
+            navigator.mediaDevices.getSupportedConstraints().facingMode &&
+            !getSupportedFacingModeLies)) {
+          delete constraints.video.facingMode;
+          let matches;
+          if (face.exact === 'environment' || face.ideal === 'environment') {
+            matches = ['back', 'rear'];
+          } else if (face.exact === 'user' || face.ideal === 'user') {
+            matches = ['front'];
+          }
+          if (matches) {
+            // Look for matches in label, or use last cam for back (typical).
+            return navigator.mediaDevices.enumerateDevices()
+              .then(devices => {
+                devices = devices.filter(d => d.kind === 'videoinput');
+                let dev = devices.find(d => matches.some(match =>
+                  d.label.toLowerCase().includes(match)));
+                if (!dev && devices.length && matches.includes('back')) {
+                  dev = devices[devices.length - 1]; // more likely the back cam
+                }
+                if (dev) {
+                  constraints.video.deviceId = face.exact ? {exact: dev.deviceId} :
+                    {ideal: dev.deviceId};
+                }
+                constraints.video = constraintsToChrome_(constraints.video);
+                logging('chrome: ' + JSON.stringify(constraints));
+                return func(constraints);
+              });
+          }
+        }
+        constraints.video = constraintsToChrome_(constraints.video);
+      }
+      logging('chrome: ' + JSON.stringify(constraints));
+      return func(constraints);
+    };
+
+    const shimError_ = function (e) {
+      if (browserDetails.version >= 64) {
+        return e;
+      }
+      return {
+        name: {
+          PermissionDeniedError: 'NotAllowedError',
+          PermissionDismissedError: 'NotAllowedError',
+          InvalidStateError: 'NotAllowedError',
+          DevicesNotFoundError: 'NotFoundError',
+          ConstraintNotSatisfiedError: 'OverconstrainedError',
+          TrackStartError: 'NotReadableError',
+          MediaDeviceFailedDueToShutdown: 'NotAllowedError',
+          MediaDeviceKillSwitchOn: 'NotAllowedError',
+          TabCaptureError: 'AbortError',
+          ScreenCaptureError: 'AbortError',
+          DeviceCaptureError: 'AbortError'
+        }[e.name] || e.name,
+        message: e.message,
+        constraint: e.constraint || e.constraintName,
+        toString() {
+          return this.name + (this.message && ': ') + this.message;
+        }
+      };
+    };
+
+    const getUserMedia_ = function (constraints, onSuccess, onError) {
+      shimConstraints_(constraints, c => {
+        navigator.webkitGetUserMedia(c, onSuccess, e => {
+          if (onError) {
+            onError(shimError_(e));
+          }
+        });
+      });
+    };
+    navigator.getUserMedia = getUserMedia_.bind(navigator);
+
+    // Even though Chrome 45 has navigator.mediaDevices and a getUserMedia
+    // function which returns a Promise, it does not accept spec-style
+    // constraints.
+    if (navigator.mediaDevices.getUserMedia) {
+      const origGetUserMedia = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
+      navigator.mediaDevices.getUserMedia = function (cs) {
+        return shimConstraints_(cs, c => origGetUserMedia(c).then(stream => {
+          if (c.audio && !stream.getAudioTracks().length ||
+            c.video && !stream.getVideoTracks().length) {
+            stream.getTracks().forEach(track => {
+              track.stop();
+            });
+            throw new DOMException('', 'NotFoundError');
+          }
+          return stream;
+        }, e => Promise.reject(shimError_(e))));
+      };
+    }
+  }
+
+  /*
+	 *  Copyright (c) 2018 The adapter.js project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+  function shimGetDisplayMedia$2(window, getSourceId) {
+    if (window.navigator.mediaDevices &&
+      'getDisplayMedia' in window.navigator.mediaDevices) {
+      return;
+    }
+    if (!(window.navigator.mediaDevices)) {
+      return;
+    }
+    // getSourceId is a function that returns a promise resolving with
+    // the sourceId of the screen/window/tab to be shared.
+    if (typeof getSourceId !== 'function') {
+      console.error('shimGetDisplayMedia: getSourceId argument is not ' +
+        'a function');
+      return;
+    }
+    window.navigator.mediaDevices.getDisplayMedia =
+      function getDisplayMedia(constraints) {
+        return getSourceId(constraints)
+          .then(sourceId => {
+            const widthSpecified = constraints.video && constraints.video.width;
+            const heightSpecified = constraints.video &&
+              constraints.video.height;
+            const frameRateSpecified = constraints.video &&
+              constraints.video.frameRate;
+            constraints.video = {
+              mandatory: {
+                chromeMediaSource: 'desktop',
+                chromeMediaSourceId: sourceId,
+                maxFrameRate: frameRateSpecified || 3
+              }
+            };
+            if (widthSpecified) {
+              constraints.video.mandatory.maxWidth = widthSpecified;
+            }
+            if (heightSpecified) {
+              constraints.video.mandatory.maxHeight = heightSpecified;
+            }
+            return window.navigator.mediaDevices.getUserMedia(constraints);
+          });
+      };
+  }
+
+  /*
+	 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  function shimMediaStream(window) {
+    window.MediaStream = window.MediaStream || window.webkitMediaStream;
+  }
+
+  function shimOnTrack$1(window) {
+    if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in
+      window.RTCPeerConnection.prototype)) {
+      Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {
+        get() {
+          return this._ontrack;
+        },
+        set(f) {
+          if (this._ontrack) {
+            this.removeEventListener('track', this._ontrack);
+          }
+          this.addEventListener('track', this._ontrack = f);
+        },
+        enumerable: true,
+        configurable: true
+      });
+      const origSetRemoteDescription =
+        window.RTCPeerConnection.prototype.setRemoteDescription;
+      window.RTCPeerConnection.prototype.setRemoteDescription =
+        function setRemoteDescription() {
+          if (!this._ontrackpoly) {
+            this._ontrackpoly = (e) => {
+              // onaddstream does not fire when a track is added to an existing
+              // stream. But stream.onaddtrack is implemented so we use that.
+              e.stream.addEventListener('addtrack', te => {
+                let receiver;
+                if (window.RTCPeerConnection.prototype.getReceivers) {
+                  receiver = this.getReceivers()
+                    .find(r => r.track && r.track.id === te.track.id);
+                } else {
+                  receiver = {track: te.track};
+                }
+
+                const event = new Event('track');
+                event.track = te.track;
+                event.receiver = receiver;
+                event.transceiver = {receiver};
+                event.streams = [e.stream];
+                this.dispatchEvent(event);
+              });
+              e.stream.getTracks().forEach(track => {
+                let receiver;
+                if (window.RTCPeerConnection.prototype.getReceivers) {
+                  receiver = this.getReceivers()
+                    .find(r => r.track && r.track.id === track.id);
+                } else {
+                  receiver = {track};
+                }
+                const event = new Event('track');
+                event.track = track;
+                event.receiver = receiver;
+                event.transceiver = {receiver};
+                event.streams = [e.stream];
+                this.dispatchEvent(event);
+              });
+            };
+            this.addEventListener('addstream', this._ontrackpoly);
+          }
+          return origSetRemoteDescription.apply(this, arguments);
+        };
+    } else {
+      // even if RTCRtpTransceiver is in window, it is only used and
+      // emitted in unified-plan. Unfortunately this means we need
+      // to unconditionally wrap the event.
+      wrapPeerConnectionEvent(window, 'track', e => {
+        if (!e.transceiver) {
+          Object.defineProperty(e, 'transceiver',
+            {value: {receiver: e.receiver}});
+        }
+        return e;
+      });
+    }
+  }
+
+  function shimGetSendersWithDtmf(window) {
+    // Overrides addTrack/removeTrack, depends on shimAddTrackRemoveTrack.
+    if (typeof window === 'object' && window.RTCPeerConnection &&
+      !('getSenders' in window.RTCPeerConnection.prototype) &&
+      'createDTMFSender' in window.RTCPeerConnection.prototype) {
+      const shimSenderWithDtmf = function (pc, track) {
+        return {
+          track,
+          get dtmf() {
+            if (this._dtmf === undefined) {
+              if (track.kind === 'audio') {
+                this._dtmf = pc.createDTMFSender(track);
+              } else {
+                this._dtmf = null;
+              }
+            }
+            return this._dtmf;
+          },
+          _pc: pc
+        };
+      };
+
+      // augment addTrack when getSenders is not available.
+      if (!window.RTCPeerConnection.prototype.getSenders) {
+        window.RTCPeerConnection.prototype.getSenders = function getSenders() {
+          this._senders = this._senders || [];
+          return this._senders.slice(); // return a copy of the internal state.
+        };
+        const origAddTrack = window.RTCPeerConnection.prototype.addTrack;
+        window.RTCPeerConnection.prototype.addTrack =
+          function addTrack(track, stream) {
+            let sender = origAddTrack.apply(this, arguments);
+            if (!sender) {
+              sender = shimSenderWithDtmf(this, track);
+              this._senders.push(sender);
+            }
+            return sender;
+          };
+
+        const origRemoveTrack = window.RTCPeerConnection.prototype.removeTrack;
+        window.RTCPeerConnection.prototype.removeTrack =
+          function removeTrack(sender) {
+            origRemoveTrack.apply(this, arguments);
+            const idx = this._senders.indexOf(sender);
+            if (idx !== -1) {
+              this._senders.splice(idx, 1);
+            }
+          };
+      }
+      const origAddStream = window.RTCPeerConnection.prototype.addStream;
+      window.RTCPeerConnection.prototype.addStream = function addStream(stream) {
+        this._senders = this._senders || [];
+        origAddStream.apply(this, [stream]);
+        stream.getTracks().forEach(track => {
+          this._senders.push(shimSenderWithDtmf(this, track));
+        });
+      };
+
+      const origRemoveStream = window.RTCPeerConnection.prototype.removeStream;
+      window.RTCPeerConnection.prototype.removeStream =
+        function removeStream(stream) {
+          this._senders = this._senders || [];
+          origRemoveStream.apply(this, [stream]);
+
+          stream.getTracks().forEach(track => {
+            const sender = this._senders.find(s => s.track === track);
+            if (sender) { // remove sender
+              this._senders.splice(this._senders.indexOf(sender), 1);
+            }
+          });
+        };
+    } else if (typeof window === 'object' && window.RTCPeerConnection &&
+      'getSenders' in window.RTCPeerConnection.prototype &&
+      'createDTMFSender' in window.RTCPeerConnection.prototype &&
+      window.RTCRtpSender &&
+      !('dtmf' in window.RTCRtpSender.prototype)) {
+      const origGetSenders = window.RTCPeerConnection.prototype.getSenders;
+      window.RTCPeerConnection.prototype.getSenders = function getSenders() {
+        const senders = origGetSenders.apply(this, []);
+        senders.forEach(sender => sender._pc = this);
+        return senders;
+      };
+
+      Object.defineProperty(window.RTCRtpSender.prototype, 'dtmf', {
+        get() {
+          if (this._dtmf === undefined) {
+            if (this.track.kind === 'audio') {
+              this._dtmf = this._pc.createDTMFSender(this.track);
+            } else {
+              this._dtmf = null;
+            }
+          }
+          return this._dtmf;
+        }
+      });
+    }
+  }
+
+  function shimGetStats(window) {
+    if (!window.RTCPeerConnection) {
+      return;
+    }
+
+    const origGetStats = window.RTCPeerConnection.prototype.getStats;
+    window.RTCPeerConnection.prototype.getStats = function getStats() {
+      const [selector, onSucc, onErr] = arguments;
+
+      // If selector is a function then we are in the old style stats so just
+      // pass back the original getStats format to avoid breaking old users.
+      if (arguments.length > 0 && typeof selector === 'function') {
+        return origGetStats.apply(this, arguments);
+      }
+
+      // When spec-style getStats is supported, return those when called with
+      // either no arguments or the selector argument is null.
+      if (origGetStats.length === 0 && (arguments.length === 0 ||
+        typeof selector !== 'function')) {
+        return origGetStats.apply(this, []);
+      }
+
+      const fixChromeStats_ = function (response) {
+        const standardReport = {};
+        const reports = response.result();
+        reports.forEach(report => {
+          const standardStats = {
+            id: report.id,
+            timestamp: report.timestamp,
+            type: {
+              localcandidate: 'local-candidate',
+              remotecandidate: 'remote-candidate'
+            }[report.type] || report.type
+          };
+          report.names().forEach(name => {
+            standardStats[name] = report.stat(name);
+          });
+          standardReport[standardStats.id] = standardStats;
+        });
+
+        return standardReport;
+      };
+
+      // shim getStats with maplike support
+      const makeMapStats = function (stats) {
+        return new Map(Object.keys(stats).map(key => [key, stats[key]]));
+      };
+
+      if (arguments.length >= 2) {
+        const successCallbackWrapper_ = function (response) {
+          onSucc(makeMapStats(fixChromeStats_(response)));
+        };
+
+        return origGetStats.apply(this, [successCallbackWrapper_,
+          selector]);
+      }
+
+      // promise-support
+      return new Promise((resolve, reject) => {
+        origGetStats.apply(this, [
+          function (response) {
+            resolve(makeMapStats(fixChromeStats_(response)));
+          }, reject]);
+      }).then(onSucc, onErr);
+    };
+  }
+
+  function shimSenderReceiverGetStats(window) {
+    if (!(typeof window === 'object' && window.RTCPeerConnection &&
+      window.RTCRtpSender && window.RTCRtpReceiver)) {
+      return;
+    }
+
+    // shim sender stats.
+    if (!('getStats' in window.RTCRtpSender.prototype)) {
+      const origGetSenders = window.RTCPeerConnection.prototype.getSenders;
+      if (origGetSenders) {
+        window.RTCPeerConnection.prototype.getSenders = function getSenders() {
+          const senders = origGetSenders.apply(this, []);
+          senders.forEach(sender => sender._pc = this);
+          return senders;
+        };
+      }
+
+      const origAddTrack = window.RTCPeerConnection.prototype.addTrack;
+      if (origAddTrack) {
+        window.RTCPeerConnection.prototype.addTrack = function addTrack() {
+          const sender = origAddTrack.apply(this, arguments);
+          sender._pc = this;
+          return sender;
+        };
+      }
+      window.RTCRtpSender.prototype.getStats = function getStats() {
+        const sender = this;
+        return this._pc.getStats().then(result =>
+          /* Note: this will include stats of all senders that
+	         *   send a track with the same id as sender.track as
+	         *   it is not possible to identify the RTCRtpSender.
+	         */
+          filterStats(result, sender.track, true));
+      };
+    }
+
+    // shim receiver stats.
+    if (!('getStats' in window.RTCRtpReceiver.prototype)) {
+      const origGetReceivers = window.RTCPeerConnection.prototype.getReceivers;
+      if (origGetReceivers) {
+        window.RTCPeerConnection.prototype.getReceivers =
+          function getReceivers() {
+            const receivers = origGetReceivers.apply(this, []);
+            receivers.forEach(receiver => receiver._pc = this);
+            return receivers;
+          };
+      }
+      wrapPeerConnectionEvent(window, 'track', e => {
+        e.receiver._pc = e.srcElement;
+        return e;
+      });
+      window.RTCRtpReceiver.prototype.getStats = function getStats() {
+        const receiver = this;
+        return this._pc.getStats().then(result =>
+          filterStats(result, receiver.track, false));
+      };
+    }
+
+    if (!('getStats' in window.RTCRtpSender.prototype &&
+      'getStats' in window.RTCRtpReceiver.prototype)) {
+      return;
+    }
+
+    // shim RTCPeerConnection.getStats(track).
+    const origGetStats = window.RTCPeerConnection.prototype.getStats;
+    window.RTCPeerConnection.prototype.getStats = function getStats() {
+      if (arguments.length > 0 &&
+        arguments[0] instanceof window.MediaStreamTrack) {
+        const track = arguments[0];
+        let sender;
+        let receiver;
+        let err;
+        this.getSenders().forEach(s => {
+          if (s.track === track) {
+            if (sender) {
+              err = true;
+            } else {
+              sender = s;
+            }
+          }
+        });
+        this.getReceivers().forEach(r => {
+          if (r.track === track) {
+            if (receiver) {
+              err = true;
+            } else {
+              receiver = r;
+            }
+          }
+          return r.track === track;
+        });
+        if (err || (sender && receiver)) {
+          return Promise.reject(new DOMException(
+            'There are more than one sender or receiver for the track.',
+            'InvalidAccessError'));
+        } else if (sender) {
+          return sender.getStats();
+        } else if (receiver) {
+          return receiver.getStats();
+        }
+        return Promise.reject(new DOMException(
+          'There is no sender or receiver for the track.',
+          'InvalidAccessError'));
+      }
+      return origGetStats.apply(this, arguments);
+    };
+  }
+
+  function shimAddTrackRemoveTrackWithNative(window) {
+    // shim addTrack/removeTrack with native variants in order to make
+    // the interactions with legacy getLocalStreams behave as in other browsers.
+    // Keeps a mapping stream.id => [stream, rtpsenders...]
+    window.RTCPeerConnection.prototype.getLocalStreams =
+      function getLocalStreams() {
+        this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+        return Object.keys(this._shimmedLocalStreams)
+          .map(streamId => this._shimmedLocalStreams[streamId][0]);
+      };
+
+    const origAddTrack = window.RTCPeerConnection.prototype.addTrack;
+    window.RTCPeerConnection.prototype.addTrack =
+      function addTrack(track, stream) {
+        if (!stream) {
+          return origAddTrack.apply(this, arguments);
+        }
+        this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+
+        const sender = origAddTrack.apply(this, arguments);
+        if (!this._shimmedLocalStreams[stream.id]) {
+          this._shimmedLocalStreams[stream.id] = [stream, sender];
+        } else if (this._shimmedLocalStreams[stream.id].indexOf(sender) === -1) {
+          this._shimmedLocalStreams[stream.id].push(sender);
+        }
+        return sender;
+      };
+
+    const origAddStream = window.RTCPeerConnection.prototype.addStream;
+    window.RTCPeerConnection.prototype.addStream = function addStream(stream) {
+      this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+
+      stream.getTracks().forEach(track => {
+        const alreadyExists = this.getSenders().find(s => s.track === track);
+        if (alreadyExists) {
+          throw new DOMException('Track already exists.',
+            'InvalidAccessError');
+        }
+      });
+      const existingSenders = this.getSenders();
+      origAddStream.apply(this, arguments);
+      const newSenders = this.getSenders()
+        .filter(newSender => existingSenders.indexOf(newSender) === -1);
+      this._shimmedLocalStreams[stream.id] = [stream].concat(newSenders);
+    };
+
+    const origRemoveStream = window.RTCPeerConnection.prototype.removeStream;
+    window.RTCPeerConnection.prototype.removeStream =
+      function removeStream(stream) {
+        this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+        delete this._shimmedLocalStreams[stream.id];
+        return origRemoveStream.apply(this, arguments);
+      };
+
+    const origRemoveTrack = window.RTCPeerConnection.prototype.removeTrack;
+    window.RTCPeerConnection.prototype.removeTrack =
+      function removeTrack(sender) {
+        this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+        if (sender) {
+          Object.keys(this._shimmedLocalStreams).forEach(streamId => {
+            const idx = this._shimmedLocalStreams[streamId].indexOf(sender);
+            if (idx !== -1) {
+              this._shimmedLocalStreams[streamId].splice(idx, 1);
+            }
+            if (this._shimmedLocalStreams[streamId].length === 1) {
+              delete this._shimmedLocalStreams[streamId];
+            }
+          });
+        }
+        return origRemoveTrack.apply(this, arguments);
+      };
+  }
+
+  function shimAddTrackRemoveTrack(window, browserDetails) {
+    if (!window.RTCPeerConnection) {
+      return;
+    }
+    // shim addTrack and removeTrack.
+    if (window.RTCPeerConnection.prototype.addTrack &&
+      browserDetails.version >= 65) {
+      return shimAddTrackRemoveTrackWithNative(window);
+    }
+
+    // also shim pc.getLocalStreams when addTrack is shimmed
+    // to return the original streams.
+    const origGetLocalStreams = window.RTCPeerConnection.prototype
+      .getLocalStreams;
+    window.RTCPeerConnection.prototype.getLocalStreams =
+      function getLocalStreams() {
+        const nativeStreams = origGetLocalStreams.apply(this);
+        this._reverseStreams = this._reverseStreams || {};
+        return nativeStreams.map(stream => this._reverseStreams[stream.id]);
+      };
+
+    const origAddStream = window.RTCPeerConnection.prototype.addStream;
+    window.RTCPeerConnection.prototype.addStream = function addStream(stream) {
+      this._streams = this._streams || {};
+      this._reverseStreams = this._reverseStreams || {};
+
+      stream.getTracks().forEach(track => {
+        const alreadyExists = this.getSenders().find(s => s.track === track);
+        if (alreadyExists) {
+          throw new DOMException('Track already exists.',
+            'InvalidAccessError');
+        }
+      });
+      // Add identity mapping for consistency with addTrack.
+      // Unless this is being used with a stream from addTrack.
+      if (!this._reverseStreams[stream.id]) {
+        const newStream = new window.MediaStream(stream.getTracks());
+        this._streams[stream.id] = newStream;
+        this._reverseStreams[newStream.id] = stream;
+        stream = newStream;
+      }
+      origAddStream.apply(this, [stream]);
+    };
+
+    const origRemoveStream = window.RTCPeerConnection.prototype.removeStream;
+    window.RTCPeerConnection.prototype.removeStream =
+      function removeStream(stream) {
+        this._streams = this._streams || {};
+        this._reverseStreams = this._reverseStreams || {};
+
+        origRemoveStream.apply(this, [(this._streams[stream.id] || stream)]);
+        delete this._reverseStreams[(this._streams[stream.id] ?
+          this._streams[stream.id].id : stream.id)];
+        delete this._streams[stream.id];
+      };
+
+    window.RTCPeerConnection.prototype.addTrack =
+      function addTrack(track, stream) {
+        if (this.signalingState === 'closed') {
+          throw new DOMException(
+            'The RTCPeerConnection\'s signalingState is \'closed\'.',
+            'InvalidStateError');
+        }
+        const streams = [].slice.call(arguments, 1);
+        if (streams.length !== 1 ||
+          !streams[0].getTracks().find(t => t === track)) {
+          // this is not fully correct but all we can manage without
+          // [[associated MediaStreams]] internal slot.
+          throw new DOMException(
+            'The adapter.js addTrack polyfill only supports a single ' +
+            ' stream which is associated with the specified track.',
+            'NotSupportedError');
+        }
+
+        const alreadyExists = this.getSenders().find(s => s.track === track);
+        if (alreadyExists) {
+          throw new DOMException('Track already exists.',
+            'InvalidAccessError');
+        }
+
+        this._streams = this._streams || {};
+        this._reverseStreams = this._reverseStreams || {};
+        const oldStream = this._streams[stream.id];
+        if (oldStream) {
+          // this is using odd Chrome behaviour, use with caution:
+          // https://bugs.chromium.org/p/webrtc/issues/detail?id=7815
+          // Note: we rely on the high-level addTrack/dtmf shim to
+          // create the sender with a dtmf sender.
+          oldStream.addTrack(track);
+
+          // Trigger ONN async.
+          Promise.resolve().then(() => {
+            this.dispatchEvent(new Event('negotiationneeded'));
+          });
+        } else {
+          const newStream = new window.MediaStream([track]);
+          this._streams[stream.id] = newStream;
+          this._reverseStreams[newStream.id] = stream;
+          this.addStream(newStream);
+        }
+        return this.getSenders().find(s => s.track === track);
+      };
+
+    // replace the internal stream id with the external one and
+    // vice versa.
+    function replaceInternalStreamId(pc, description) {
+      let sdp = description.sdp;
+      Object.keys(pc._reverseStreams || []).forEach(internalId => {
+        const externalStream = pc._reverseStreams[internalId];
+        const internalStream = pc._streams[externalStream.id];
+        sdp = sdp.replace(new RegExp(internalStream.id, 'g'),
+          externalStream.id);
+      });
+      return new RTCSessionDescription({
+        type: description.type,
+        sdp
+      });
+    }
+
+    function replaceExternalStreamId(pc, description) {
+      let sdp = description.sdp;
+      Object.keys(pc._reverseStreams || []).forEach(internalId => {
+        const externalStream = pc._reverseStreams[internalId];
+        const internalStream = pc._streams[externalStream.id];
+        sdp = sdp.replace(new RegExp(externalStream.id, 'g'),
+          internalStream.id);
+      });
+      return new RTCSessionDescription({
+        type: description.type,
+        sdp
+      });
+    }
+
+    ['createOffer', 'createAnswer'].forEach(function (method) {
+      const nativeMethod = window.RTCPeerConnection.prototype[method];
+      const methodObj = {
+        [method]() {
+          const args = arguments;
+          const isLegacyCall = arguments.length &&
+            typeof arguments[0] === 'function';
+          if (isLegacyCall) {
+            return nativeMethod.apply(this, [
+              (description) => {
+                const desc = replaceInternalStreamId(this, description);
+                args[0].apply(null, [desc]);
+              },
+              (err) => {
+                if (args[1]) {
+                  args[1].apply(null, err);
+                }
+              }, arguments[2]
+            ]);
+          }
+          return nativeMethod.apply(this, arguments)
+            .then(description => replaceInternalStreamId(this, description));
+        }
+      };
+      window.RTCPeerConnection.prototype[method] = methodObj[method];
+    });
+
+    const origSetLocalDescription =
+      window.RTCPeerConnection.prototype.setLocalDescription;
+    window.RTCPeerConnection.prototype.setLocalDescription =
+      function setLocalDescription() {
+        if (!arguments.length || !arguments[0].type) {
+          return origSetLocalDescription.apply(this, arguments);
+        }
+        arguments[0] = replaceExternalStreamId(this, arguments[0]);
+        return origSetLocalDescription.apply(this, arguments);
+      };
+
+    // TODO: mangle getStats: https://w3c.github.io/webrtc-stats/#dom-rtcmediastreamstats-streamidentifier
+
+    const origLocalDescription = Object.getOwnPropertyDescriptor(
+      window.RTCPeerConnection.prototype, 'localDescription');
+    Object.defineProperty(window.RTCPeerConnection.prototype,
+      'localDescription', {
+        get() {
+          const description = origLocalDescription.get.apply(this);
+          if (description.type === '') {
+            return description;
+          }
+          return replaceInternalStreamId(this, description);
+        }
+      });
+
+    window.RTCPeerConnection.prototype.removeTrack =
+      function removeTrack(sender) {
+        if (this.signalingState === 'closed') {
+          throw new DOMException(
+            'The RTCPeerConnection\'s signalingState is \'closed\'.',
+            'InvalidStateError');
+        }
+        // We can not yet check for sender instanceof RTCRtpSender
+        // since we shim RTPSender. So we check if sender._pc is set.
+        if (!sender._pc) {
+          throw new DOMException('Argument 1 of RTCPeerConnection.removeTrack ' +
+            'does not implement interface RTCRtpSender.', 'TypeError');
+        }
+        const isLocal = sender._pc === this;
+        if (!isLocal) {
+          throw new DOMException('Sender was not created by this connection.',
+            'InvalidAccessError');
+        }
+
+        // Search for the native stream the senders track belongs to.
+        this._streams = this._streams || {};
+        let stream;
+        Object.keys(this._streams).forEach(streamid => {
+          const hasTrack = this._streams[streamid].getTracks()
+            .find(track => sender.track === track);
+          if (hasTrack) {
+            stream = this._streams[streamid];
+          }
+        });
+
+        if (stream) {
+          if (stream.getTracks().length === 1) {
+            // if this is the last track of the stream, remove the stream. This
+            // takes care of any shimmed _senders.
+            this.removeStream(this._reverseStreams[stream.id]);
+          } else {
+            // relying on the same odd chrome behaviour as above.
+            stream.removeTrack(sender.track);
+          }
+          this.dispatchEvent(new Event('negotiationneeded'));
+        }
+      };
+  }
+
+  function shimPeerConnection$2(window, browserDetails) {
+    if (!window.RTCPeerConnection && window.webkitRTCPeerConnection) {
+      // very basic support for old versions.
+      window.RTCPeerConnection = window.webkitRTCPeerConnection;
+    }
+    if (!window.RTCPeerConnection) {
+      return;
+    }
+
+    // shim implicit creation of RTCSessionDescription/RTCIceCandidate
+    if (browserDetails.version < 53) {
+      ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
+        .forEach(function (method) {
+          const nativeMethod = window.RTCPeerConnection.prototype[method];
+          const methodObj = {
+            [method]() {
+              arguments[0] = new ((method === 'addIceCandidate') ?
+                window.RTCIceCandidate :
+                window.RTCSessionDescription)(arguments[0]);
+              return nativeMethod.apply(this, arguments);
+            }
+          };
+          window.RTCPeerConnection.prototype[method] = methodObj[method];
+        });
+    }
+  }
+
+  // Attempt to fix ONN in plan-b mode.
+  function fixNegotiationNeeded(window, browserDetails) {
+    wrapPeerConnectionEvent(window, 'negotiationneeded', e => {
+      const pc = e.target;
+      if (browserDetails.version < 72 || (pc.getConfiguration &&
+        pc.getConfiguration().sdpSemantics === 'plan-b')) {
+        if (pc.signalingState !== 'stable') {
+          return;
+        }
+      }
+      return e;
+    });
+  }
+
+  var chromeShim = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    shimMediaStream: shimMediaStream,
+    shimOnTrack: shimOnTrack$1,
+    shimGetSendersWithDtmf: shimGetSendersWithDtmf,
+    shimGetStats: shimGetStats,
+    shimSenderReceiverGetStats: shimSenderReceiverGetStats,
+    shimAddTrackRemoveTrackWithNative: shimAddTrackRemoveTrackWithNative,
+    shimAddTrackRemoveTrack: shimAddTrackRemoveTrack,
+    shimPeerConnection: shimPeerConnection$2,
+    fixNegotiationNeeded: fixNegotiationNeeded,
+    shimGetUserMedia: shimGetUserMedia$3,
+    shimGetDisplayMedia: shimGetDisplayMedia$2
+  });
+
+  /*
+	 *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+  // Edge does not like
+  // 1) stun: filtered after 14393 unless ?transport=udp is present
+  // 2) turn: that does not have all of turn:host:port?transport=udp
+  // 3) turn: with ipv6 addresses
+  // 4) turn: occurring muliple times
+  function filterIceServers$1(iceServers, edgeVersion) {
+    let hasTurn = false;
+    iceServers = JSON.parse(JSON.stringify(iceServers));
+    return iceServers.filter(server => {
+      if (server && (server.urls || server.url)) {
+        let urls = server.urls || server.url;
+        if (server.url && !server.urls) {
+          deprecated('RTCIceServer.url', 'RTCIceServer.urls');
+        }
+        const isString = typeof urls === 'string';
+        if (isString) {
+          urls = [urls];
+        }
+        urls = urls.filter(url => {
+          // filter STUN unconditionally.
+          if (url.indexOf('stun:') === 0) {
+            return false;
+          }
+
+          const validTurn = url.startsWith('turn') &&
+            !url.startsWith('turn:[') &&
+            url.includes('transport=udp');
+          if (validTurn && !hasTurn) {
+            hasTurn = true;
+            return true;
+          }
+          return validTurn && !hasTurn;
+        });
+
+        delete server.url;
+        server.urls = isString ? urls[0] : urls;
+        return !!urls.length;
+      }
+    });
+  }
+
+  function createCommonjsModule(fn) {
+    var module = {exports: {}};
+    return fn(module, module.exports), module.exports;
+  }
+
+  /* eslint-env node */
+
+  var sdp = createCommonjsModule(function (module) {
+
+    // SDP helpers.
+    var SDPUtils = {};
+
+    // Generate an alphanumeric identifier for cname or mids.
+    // TODO: use UUIDs instead? https://gist.github.com/jed/982883
+    SDPUtils.generateIdentifier = function () {
+      return Math.random().toString(36).substr(2, 10);
+    };
+
+    // The RTCP CNAME used by all peerconnections from the same JS.
+    SDPUtils.localCName = SDPUtils.generateIdentifier();
+
+    // Splits SDP into lines, dealing with both CRLF and LF.
+    SDPUtils.splitLines = function (blob) {
+      return blob.trim().split('\n').map(function (line) {
+        return line.trim();
+      });
+    };
+    // Splits SDP into sessionpart and mediasections. Ensures CRLF.
+    SDPUtils.splitSections = function (blob) {
+      var parts = blob.split('\nm=');
+      return parts.map(function (part, index) {
+        return (index > 0 ? 'm=' + part : part).trim() + '\r\n';
+      });
+    };
+
+    // returns the session description.
+    SDPUtils.getDescription = function (blob) {
+      var sections = SDPUtils.splitSections(blob);
+      return sections && sections[0];
+    };
+
+    // returns the individual media sections.
+    SDPUtils.getMediaSections = function (blob) {
+      var sections = SDPUtils.splitSections(blob);
+      sections.shift();
+      return sections;
+    };
+
+    // Returns lines that start with a certain prefix.
+    SDPUtils.matchPrefix = function (blob, prefix) {
+      return SDPUtils.splitLines(blob).filter(function (line) {
+        return line.indexOf(prefix) === 0;
+      });
+    };
+
+    // Parses an ICE candidate line. Sample input:
+    // candidate:702786350 2 udp 41819902 8.8.8.8 60769 typ relay raddr 8.8.8.8
+    // rport 55996"
+    SDPUtils.parseCandidate = function (line) {
+      var parts;
+      // Parse both variants.
+      if (line.indexOf('a=candidate:') === 0) {
+        parts = line.substring(12).split(' ');
+      } else {
+        parts = line.substring(10).split(' ');
+      }
+
+      var candidate = {
+        foundation: parts[0],
+        component: parseInt(parts[1], 10),
+        protocol: parts[2].toLowerCase(),
+        priority: parseInt(parts[3], 10),
+        ip: parts[4],
+        address: parts[4], // address is an alias for ip.
+        port: parseInt(parts[5], 10),
+        // skip parts[6] == 'typ'
+        type: parts[7]
+      };
+
+      for (var i = 8; i < parts.length; i += 2) {
+        switch (parts[i]) {
+          case 'raddr':
+            candidate.relatedAddress = parts[i + 1];
+            break;
+          case 'rport':
+            candidate.relatedPort = parseInt(parts[i + 1], 10);
+            break;
+          case 'tcptype':
+            candidate.tcpType = parts[i + 1];
+            break;
+          case 'ufrag':
+            candidate.ufrag = parts[i + 1]; // for backward compability.
+            candidate.usernameFragment = parts[i + 1];
+            break;
+          default: // extension handling, in particular ufrag
+            candidate[parts[i]] = parts[i + 1];
+            break;
+        }
+      }
+      return candidate;
+    };
+
+    // Translates a candidate object into SDP candidate attribute.
+    SDPUtils.writeCandidate = function (candidate) {
+      var sdp = [];
+      sdp.push(candidate.foundation);
+      sdp.push(candidate.component);
+      sdp.push(candidate.protocol.toUpperCase());
+      sdp.push(candidate.priority);
+      sdp.push(candidate.address || candidate.ip);
+      sdp.push(candidate.port);
+
+      var type = candidate.type;
+      sdp.push('typ');
+      sdp.push(type);
+      if (type !== 'host' && candidate.relatedAddress &&
+        candidate.relatedPort) {
+        sdp.push('raddr');
+        sdp.push(candidate.relatedAddress);
+        sdp.push('rport');
+        sdp.push(candidate.relatedPort);
+      }
+      if (candidate.tcpType && candidate.protocol.toLowerCase() === 'tcp') {
+        sdp.push('tcptype');
+        sdp.push(candidate.tcpType);
+      }
+      if (candidate.usernameFragment || candidate.ufrag) {
+        sdp.push('ufrag');
+        sdp.push(candidate.usernameFragment || candidate.ufrag);
+      }
+      return 'candidate:' + sdp.join(' ');
+    };
+
+    // Parses an ice-options line, returns an array of option tags.
+    // a=ice-options:foo bar
+    SDPUtils.parseIceOptions = function (line) {
+      return line.substr(14).split(' ');
+    };
+
+    // Parses an rtpmap line, returns RTCRtpCoddecParameters. Sample input:
+    // a=rtpmap:111 opus/48000/2
+    SDPUtils.parseRtpMap = function (line) {
+      var parts = line.substr(9).split(' ');
+      var parsed = {
+        payloadType: parseInt(parts.shift(), 10) // was: id
+      };
+
+      parts = parts[0].split('/');
+
+      parsed.name = parts[0];
+      parsed.clockRate = parseInt(parts[1], 10); // was: clockrate
+      parsed.channels = parts.length === 3 ? parseInt(parts[2], 10) : 1;
+      // legacy alias, got renamed back to channels in ORTC.
+      parsed.numChannels = parsed.channels;
+      return parsed;
+    };
+
+    // Generate an a=rtpmap line from RTCRtpCodecCapability or
+    // RTCRtpCodecParameters.
+    SDPUtils.writeRtpMap = function (codec) {
+      var pt = codec.payloadType;
+      if (codec.preferredPayloadType !== undefined) {
+        pt = codec.preferredPayloadType;
+      }
+      var channels = codec.channels || codec.numChannels || 1;
+      return 'a=rtpmap:' + pt + ' ' + codec.name + '/' + codec.clockRate +
+        (channels !== 1 ? '/' + channels : '') + '\r\n';
+    };
+
+    // Parses an a=extmap line (headerextension from RFC 5285). Sample input:
+    // a=extmap:2 urn:ietf:params:rtp-hdrext:toffset
+    // a=extmap:2/sendonly urn:ietf:params:rtp-hdrext:toffset
+    SDPUtils.parseExtmap = function (line) {
+      var parts = line.substr(9).split(' ');
+      return {
+        id: parseInt(parts[0], 10),
+        direction: parts[0].indexOf('/') > 0 ? parts[0].split('/')[1] : 'sendrecv',
+        uri: parts[1]
+      };
+    };
+
+    // Generates a=extmap line from RTCRtpHeaderExtensionParameters or
+    // RTCRtpHeaderExtension.
+    SDPUtils.writeExtmap = function (headerExtension) {
+      return 'a=extmap:' + (headerExtension.id || headerExtension.preferredId) +
+        (headerExtension.direction && headerExtension.direction !== 'sendrecv'
+          ? '/' + headerExtension.direction
+          : '') +
+        ' ' + headerExtension.uri + '\r\n';
+    };
+
+    // Parses an ftmp line, returns dictionary. Sample input:
+    // a=fmtp:96 vbr=on;cng=on
+    // Also deals with vbr=on; cng=on
+    SDPUtils.parseFmtp = function (line) {
+      var parsed = {};
+      var kv;
+      var parts = line.substr(line.indexOf(' ') + 1).split(';');
+      for (var j = 0; j < parts.length; j++) {
+        kv = parts[j].trim().split('=');
+        parsed[kv[0].trim()] = kv[1];
+      }
+      return parsed;
+    };
+
+    // Generates an a=ftmp line from RTCRtpCodecCapability or RTCRtpCodecParameters.
+    SDPUtils.writeFmtp = function (codec) {
+      var line = '';
+      var pt = codec.payloadType;
+      if (codec.preferredPayloadType !== undefined) {
+        pt = codec.preferredPayloadType;
+      }
+      if (codec.parameters && Object.keys(codec.parameters).length) {
+        var params = [];
+        Object.keys(codec.parameters).forEach(function (param) {
+          if (codec.parameters[param]) {
+            params.push(param + '=' + codec.parameters[param]);
+          } else {
+            params.push(param);
+          }
+        });
+        line += 'a=fmtp:' + pt + ' ' + params.join(';') + '\r\n';
+      }
+      return line;
+    };
+
+    // Parses an rtcp-fb line, returns RTCPRtcpFeedback object. Sample input:
+    // a=rtcp-fb:98 nack rpsi
+    SDPUtils.parseRtcpFb = function (line) {
+      var parts = line.substr(line.indexOf(' ') + 1).split(' ');
+      return {
+        type: parts.shift(),
+        parameter: parts.join(' ')
+      };
+    };
+    // Generate a=rtcp-fb lines from RTCRtpCodecCapability or RTCRtpCodecParameters.
+    SDPUtils.writeRtcpFb = function (codec) {
+      var lines = '';
+      var pt = codec.payloadType;
+      if (codec.preferredPayloadType !== undefined) {
+        pt = codec.preferredPayloadType;
+      }
+      if (codec.rtcpFeedback && codec.rtcpFeedback.length) {
+        // FIXME: special handling for trr-int?
+        codec.rtcpFeedback.forEach(function (fb) {
+          lines += 'a=rtcp-fb:' + pt + ' ' + fb.type +
+            (fb.parameter && fb.parameter.length ? ' ' + fb.parameter : '') +
+            '\r\n';
+        });
+      }
+      return lines;
+    };
+
+    // Parses an RFC 5576 ssrc media attribute. Sample input:
+    // a=ssrc:3735928559 cname:something
+    SDPUtils.parseSsrcMedia = function (line) {
+      var sp = line.indexOf(' ');
+      var parts = {
+        ssrc: parseInt(line.substr(7, sp - 7), 10)
+      };
+      var colon = line.indexOf(':', sp);
+      if (colon > -1) {
+        parts.attribute = line.substr(sp + 1, colon - sp - 1);
+        parts.value = line.substr(colon + 1);
+      } else {
+        parts.attribute = line.substr(sp + 1);
+      }
+      return parts;
+    };
+
+    SDPUtils.parseSsrcGroup = function (line) {
+      var parts = line.substr(13).split(' ');
+      return {
+        semantics: parts.shift(),
+        ssrcs: parts.map(function (ssrc) {
+          return parseInt(ssrc, 10);
+        })
+      };
+    };
+
+    // Extracts the MID (RFC 5888) from a media section.
+    // returns the MID or undefined if no mid line was found.
+    SDPUtils.getMid = function (mediaSection) {
+      var mid = SDPUtils.matchPrefix(mediaSection, 'a=mid:')[0];
+      if (mid) {
+        return mid.substr(6);
+      }
+    };
+
+    SDPUtils.parseFingerprint = function (line) {
+      var parts = line.substr(14).split(' ');
+      return {
+        algorithm: parts[0].toLowerCase(), // algorithm is case-sensitive in Edge.
+        value: parts[1]
+      };
+    };
+
+    // Extracts DTLS parameters from SDP media section or sessionpart.
+    // FIXME: for consistency with other functions this should only
+    //   get the fingerprint line as input. See also getIceParameters.
+    SDPUtils.getDtlsParameters = function (mediaSection, sessionpart) {
+      var lines = SDPUtils.matchPrefix(mediaSection + sessionpart,
+        'a=fingerprint:');
+      // Note: a=setup line is ignored since we use the 'auto' role.
+      // Note2: 'algorithm' is not case sensitive except in Edge.
+      return {
+        role: 'auto',
+        fingerprints: lines.map(SDPUtils.parseFingerprint)
+      };
+    };
+
+    // Serializes DTLS parameters to SDP.
+    SDPUtils.writeDtlsParameters = function (params, setupType) {
+      var sdp = 'a=setup:' + setupType + '\r\n';
+      params.fingerprints.forEach(function (fp) {
+        sdp += 'a=fingerprint:' + fp.algorithm + ' ' + fp.value + '\r\n';
+      });
+      return sdp;
+    };
+
+    // Parses a=crypto lines into
+    //   https://rawgit.com/aboba/edgertc/master/msortc-rs4.html#dictionary-rtcsrtpsdesparameters-members
+    SDPUtils.parseCryptoLine = function (line) {
+      var parts = line.substr(9).split(' ');
+      return {
+        tag: parseInt(parts[0], 10),
+        cryptoSuite: parts[1],
+        keyParams: parts[2],
+        sessionParams: parts.slice(3),
+      };
+    };
+
+    SDPUtils.writeCryptoLine = function (parameters) {
+      return 'a=crypto:' + parameters.tag + ' ' +
+        parameters.cryptoSuite + ' ' +
+        (typeof parameters.keyParams === 'object'
+          ? SDPUtils.writeCryptoKeyParams(parameters.keyParams)
+          : parameters.keyParams) +
+        (parameters.sessionParams ? ' ' + parameters.sessionParams.join(' ') : '') +
+        '\r\n';
+    };
+
+    // Parses the crypto key parameters into
+    //   https://rawgit.com/aboba/edgertc/master/msortc-rs4.html#rtcsrtpkeyparam*
+    SDPUtils.parseCryptoKeyParams = function (keyParams) {
+      if (keyParams.indexOf('inline:') !== 0) {
+        return null;
+      }
+      var parts = keyParams.substr(7).split('|');
+      return {
+        keyMethod: 'inline',
+        keySalt: parts[0],
+        lifeTime: parts[1],
+        mkiValue: parts[2] ? parts[2].split(':')[0] : undefined,
+        mkiLength: parts[2] ? parts[2].split(':')[1] : undefined,
+      };
+    };
+
+    SDPUtils.writeCryptoKeyParams = function (keyParams) {
+      return keyParams.keyMethod + ':'
+        + keyParams.keySalt +
+        (keyParams.lifeTime ? '|' + keyParams.lifeTime : '') +
+        (keyParams.mkiValue && keyParams.mkiLength
+          ? '|' + keyParams.mkiValue + ':' + keyParams.mkiLength
+          : '');
+    };
+
+    // Extracts all SDES paramters.
+    SDPUtils.getCryptoParameters = function (mediaSection, sessionpart) {
+      var lines = SDPUtils.matchPrefix(mediaSection + sessionpart,
+        'a=crypto:');
+      return lines.map(SDPUtils.parseCryptoLine);
+    };
+
+    // Parses ICE information from SDP media section or sessionpart.
+    // FIXME: for consistency with other functions this should only
+    //   get the ice-ufrag and ice-pwd lines as input.
+    SDPUtils.getIceParameters = function (mediaSection, sessionpart) {
+      var ufrag = SDPUtils.matchPrefix(mediaSection + sessionpart,
+        'a=ice-ufrag:')[0];
+      var pwd = SDPUtils.matchPrefix(mediaSection + sessionpart,
+        'a=ice-pwd:')[0];
+      if (!(ufrag && pwd)) {
+        return null;
+      }
+      return {
+        usernameFragment: ufrag.substr(12),
+        password: pwd.substr(10),
+      };
+    };
+
+    // Serializes ICE parameters to SDP.
+    SDPUtils.writeIceParameters = function (params) {
+      return 'a=ice-ufrag:' + params.usernameFragment + '\r\n' +
+        'a=ice-pwd:' + params.password + '\r\n';
+    };
+
+    // Parses the SDP media section and returns RTCRtpParameters.
+    SDPUtils.parseRtpParameters = function (mediaSection) {
+      var description = {
+        codecs: [],
+        headerExtensions: [],
+        fecMechanisms: [],
+        rtcp: []
+      };
+      var lines = SDPUtils.splitLines(mediaSection);
+      var mline = lines[0].split(' ');
+      for (var i = 3; i < mline.length; i++) { // find all codecs from mline[3..]
+        var pt = mline[i];
+        var rtpmapline = SDPUtils.matchPrefix(
+          mediaSection, 'a=rtpmap:' + pt + ' ')[0];
+        if (rtpmapline) {
+          var codec = SDPUtils.parseRtpMap(rtpmapline);
+          var fmtps = SDPUtils.matchPrefix(
+            mediaSection, 'a=fmtp:' + pt + ' ');
+          // Only the first a=fmtp:<pt> is considered.
+          codec.parameters = fmtps.length ? SDPUtils.parseFmtp(fmtps[0]) : {};
+          codec.rtcpFeedback = SDPUtils.matchPrefix(
+            mediaSection, 'a=rtcp-fb:' + pt + ' ')
+            .map(SDPUtils.parseRtcpFb);
+          description.codecs.push(codec);
+          // parse FEC mechanisms from rtpmap lines.
+          switch (codec.name.toUpperCase()) {
+            case 'RED':
+            case 'ULPFEC':
+              description.fecMechanisms.push(codec.name.toUpperCase());
+              break;
+          }
+        }
+      }
+      SDPUtils.matchPrefix(mediaSection, 'a=extmap:').forEach(function (line) {
+        description.headerExtensions.push(SDPUtils.parseExtmap(line));
+      });
+      // FIXME: parse rtcp.
+      return description;
+    };
+
+    // Generates parts of the SDP media section describing the capabilities /
+    // parameters.
+    SDPUtils.writeRtpDescription = function (kind, caps) {
+      var sdp = '';
+
+      // Build the mline.
+      sdp += 'm=' + kind + ' ';
+      sdp += caps.codecs.length > 0 ? '9' : '0'; // reject if no codecs.
+      sdp += ' UDP/TLS/RTP/SAVPF ';
+      sdp += caps.codecs.map(function (codec) {
+        if (codec.preferredPayloadType !== undefined) {
+          return codec.preferredPayloadType;
+        }
+        return codec.payloadType;
+      }).join(' ') + '\r\n';
+
+      sdp += 'c=IN IP4 0.0.0.0\r\n';
+      sdp += 'a=rtcp:9 IN IP4 0.0.0.0\r\n';
+
+      // Add a=rtpmap lines for each codec. Also fmtp and rtcp-fb.
+      caps.codecs.forEach(function (codec) {
+        sdp += SDPUtils.writeRtpMap(codec);
+        sdp += SDPUtils.writeFmtp(codec);
+        sdp += SDPUtils.writeRtcpFb(codec);
+      });
+      var maxptime = 0;
+      caps.codecs.forEach(function (codec) {
+        if (codec.maxptime > maxptime) {
+          maxptime = codec.maxptime;
+        }
+      });
+      if (maxptime > 0) {
+        sdp += 'a=maxptime:' + maxptime + '\r\n';
+      }
+      sdp += 'a=rtcp-mux\r\n';
+
+      if (caps.headerExtensions) {
+        caps.headerExtensions.forEach(function (extension) {
+          sdp += SDPUtils.writeExtmap(extension);
+        });
+      }
+      // FIXME: write fecMechanisms.
+      return sdp;
+    };
+
+    // Parses the SDP media section and returns an array of
+    // RTCRtpEncodingParameters.
+    SDPUtils.parseRtpEncodingParameters = function (mediaSection) {
+      var encodingParameters = [];
+      var description = SDPUtils.parseRtpParameters(mediaSection);
+      var hasRed = description.fecMechanisms.indexOf('RED') !== -1;
+      var hasUlpfec = description.fecMechanisms.indexOf('ULPFEC') !== -1;
+
+      // filter a=ssrc:... cname:, ignore PlanB-msid
+      var ssrcs = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+        .map(function (line) {
+          return SDPUtils.parseSsrcMedia(line);
+        })
+        .filter(function (parts) {
+          return parts.attribute === 'cname';
+        });
+      var primarySsrc = ssrcs.length > 0 && ssrcs[0].ssrc;
+      var secondarySsrc;
+
+      var flows = SDPUtils.matchPrefix(mediaSection, 'a=ssrc-group:FID')
+        .map(function (line) {
+          var parts = line.substr(17).split(' ');
+          return parts.map(function (part) {
+            return parseInt(part, 10);
+          });
+        });
+      if (flows.length > 0 && flows[0].length > 1 && flows[0][0] === primarySsrc) {
+        secondarySsrc = flows[0][1];
+      }
+
+      description.codecs.forEach(function (codec) {
+        if (codec.name.toUpperCase() === 'RTX' && codec.parameters.apt) {
+          var encParam = {
+            ssrc: primarySsrc,
+            codecPayloadType: parseInt(codec.parameters.apt, 10)
+          };
+          if (primarySsrc && secondarySsrc) {
+            encParam.rtx = {ssrc: secondarySsrc};
+          }
+          encodingParameters.push(encParam);
+          if (hasRed) {
+            encParam = JSON.parse(JSON.stringify(encParam));
+            encParam.fec = {
+              ssrc: primarySsrc,
+              mechanism: hasUlpfec ? 'red+ulpfec' : 'red'
+            };
+            encodingParameters.push(encParam);
+          }
+        }
+      });
+      if (encodingParameters.length === 0 && primarySsrc) {
+        encodingParameters.push({
+          ssrc: primarySsrc
+        });
+      }
+
+      // we support both b=AS and b=TIAS but interpret AS as TIAS.
+      var bandwidth = SDPUtils.matchPrefix(mediaSection, 'b=');
+      if (bandwidth.length) {
+        if (bandwidth[0].indexOf('b=TIAS:') === 0) {
+          bandwidth = parseInt(bandwidth[0].substr(7), 10);
+        } else if (bandwidth[0].indexOf('b=AS:') === 0) {
+          // use formula from JSEP to convert b=AS to TIAS value.
+          bandwidth = parseInt(bandwidth[0].substr(5), 10) * 1000 * 0.95
+            - (50 * 40 * 8);
+        } else {
+          bandwidth = undefined;
+        }
+        encodingParameters.forEach(function (params) {
+          params.maxBitrate = bandwidth;
+        });
+      }
+      return encodingParameters;
+    };
+
+    // parses http://draft.ortc.org/#rtcrtcpparameters*
+    SDPUtils.parseRtcpParameters = function (mediaSection) {
+      var rtcpParameters = {};
+
+      // Gets the first SSRC. Note tha with RTX there might be multiple
+      // SSRCs.
+      var remoteSsrc = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+        .map(function (line) {
+          return SDPUtils.parseSsrcMedia(line);
+        })
+        .filter(function (obj) {
+          return obj.attribute === 'cname';
+        })[0];
+      if (remoteSsrc) {
+        rtcpParameters.cname = remoteSsrc.value;
+        rtcpParameters.ssrc = remoteSsrc.ssrc;
+      }
+
+      // Edge uses the compound attribute instead of reducedSize
+      // compound is !reducedSize
+      var rsize = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-rsize');
+      rtcpParameters.reducedSize = rsize.length > 0;
+      rtcpParameters.compound = rsize.length === 0;
+
+      // parses the rtcp-mux attrіbute.
+      // Note that Edge does not support unmuxed RTCP.
+      var mux = SDPUtils.matchPrefix(mediaSection, 'a=rtcp-mux');
+      rtcpParameters.mux = mux.length > 0;
+
+      return rtcpParameters;
+    };
+
+    // parses either a=msid: or a=ssrc:... msid lines and returns
+    // the id of the MediaStream and MediaStreamTrack.
+    SDPUtils.parseMsid = function (mediaSection) {
+      var parts;
+      var spec = SDPUtils.matchPrefix(mediaSection, 'a=msid:');
+      if (spec.length === 1) {
+        parts = spec[0].substr(7).split(' ');
+        return {stream: parts[0], track: parts[1]};
+      }
+      var planB = SDPUtils.matchPrefix(mediaSection, 'a=ssrc:')
+        .map(function (line) {
+          return SDPUtils.parseSsrcMedia(line);
+        })
+        .filter(function (msidParts) {
+          return msidParts.attribute === 'msid';
+        });
+      if (planB.length > 0) {
+        parts = planB[0].value.split(' ');
+        return {stream: parts[0], track: parts[1]};
+      }
+    };
+
+    // SCTP
+    // parses draft-ietf-mmusic-sctp-sdp-26 first and falls back
+    // to draft-ietf-mmusic-sctp-sdp-05
+    SDPUtils.parseSctpDescription = function (mediaSection) {
+      var mline = SDPUtils.parseMLine(mediaSection);
+      var maxSizeLine = SDPUtils.matchPrefix(mediaSection, 'a=max-message-size:');
+      var maxMessageSize;
+      if (maxSizeLine.length > 0) {
+        maxMessageSize = parseInt(maxSizeLine[0].substr(19), 10);
+      }
+      if (isNaN(maxMessageSize)) {
+        maxMessageSize = 65536;
+      }
+      var sctpPort = SDPUtils.matchPrefix(mediaSection, 'a=sctp-port:');
+      if (sctpPort.length > 0) {
+        return {
+          port: parseInt(sctpPort[0].substr(12), 10),
+          protocol: mline.fmt,
+          maxMessageSize: maxMessageSize
+        };
+      }
+      var sctpMapLines = SDPUtils.matchPrefix(mediaSection, 'a=sctpmap:');
+      if (sctpMapLines.length > 0) {
+        var parts = SDPUtils.matchPrefix(mediaSection, 'a=sctpmap:')[0]
+          .substr(10)
+          .split(' ');
+        return {
+          port: parseInt(parts[0], 10),
+          protocol: parts[1],
+          maxMessageSize: maxMessageSize
+        };
+      }
+    };
+
+    // SCTP
+    // outputs the draft-ietf-mmusic-sctp-sdp-26 version that all browsers
+    // support by now receiving in this format, unless we originally parsed
+    // as the draft-ietf-mmusic-sctp-sdp-05 format (indicated by the m-line
+    // protocol of DTLS/SCTP -- without UDP/ or TCP/)
+    SDPUtils.writeSctpDescription = function (media, sctp) {
+      var output = [];
+      if (media.protocol !== 'DTLS/SCTP') {
+        output = [
+          'm=' + media.kind + ' 9 ' + media.protocol + ' ' + sctp.protocol + '\r\n',
+          'c=IN IP4 0.0.0.0\r\n',
+          'a=sctp-port:' + sctp.port + '\r\n'
+        ];
+      } else {
+        output = [
+          'm=' + media.kind + ' 9 ' + media.protocol + ' ' + sctp.port + '\r\n',
+          'c=IN IP4 0.0.0.0\r\n',
+          'a=sctpmap:' + sctp.port + ' ' + sctp.protocol + ' 65535\r\n'
+        ];
+      }
+      if (sctp.maxMessageSize !== undefined) {
+        output.push('a=max-message-size:' + sctp.maxMessageSize + '\r\n');
+      }
+      return output.join('');
+    };
+
+    // Generate a session ID for SDP.
+    // https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-20#section-5.2.1
+    // recommends using a cryptographically random +ve 64-bit value
+    // but right now this should be acceptable and within the right range
+    SDPUtils.generateSessionId = function () {
+      return Math.random().toString().substr(2, 21);
+    };
+
+    // Write boilder plate for start of SDP
+    // sessId argument is optional - if not supplied it will
+    // be generated randomly
+    // sessVersion is optional and defaults to 2
+    // sessUser is optional and defaults to 'thisisadapterortc'
+    SDPUtils.writeSessionBoilerplate = function (sessId, sessVer, sessUser) {
+      var sessionId;
+      var version = sessVer !== undefined ? sessVer : 2;
+      if (sessId) {
+        sessionId = sessId;
+      } else {
+        sessionId = SDPUtils.generateSessionId();
+      }
+      var user = sessUser || 'thisisadapterortc';
+      // FIXME: sess-id should be an NTP timestamp.
+      return 'v=0\r\n' +
+        'o=' + user + ' ' + sessionId + ' ' + version +
+        ' IN IP4 127.0.0.1\r\n' +
+        's=-\r\n' +
+        't=0 0\r\n';
+    };
+
+    SDPUtils.writeMediaSection = function (transceiver, caps, type, stream) {
+      var sdp = SDPUtils.writeRtpDescription(transceiver.kind, caps);
+
+      // Map ICE parameters (ufrag, pwd) to SDP.
+      sdp += SDPUtils.writeIceParameters(
+        transceiver.iceGatherer.getLocalParameters());
+
+      // Map DTLS parameters to SDP.
+      sdp += SDPUtils.writeDtlsParameters(
+        transceiver.dtlsTransport.getLocalParameters(),
+        type === 'offer' ? 'actpass' : 'active');
+
+      sdp += 'a=mid:' + transceiver.mid + '\r\n';
+
+      if (transceiver.direction) {
+        sdp += 'a=' + transceiver.direction + '\r\n';
+      } else if (transceiver.rtpSender && transceiver.rtpReceiver) {
+        sdp += 'a=sendrecv\r\n';
+      } else if (transceiver.rtpSender) {
+        sdp += 'a=sendonly\r\n';
+      } else if (transceiver.rtpReceiver) {
+        sdp += 'a=recvonly\r\n';
+      } else {
+        sdp += 'a=inactive\r\n';
+      }
+
+      if (transceiver.rtpSender) {
+        // spec.
+        var msid = 'msid:' + stream.id + ' ' +
+          transceiver.rtpSender.track.id + '\r\n';
+        sdp += 'a=' + msid;
+
+        // for Chrome.
+        sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+          ' ' + msid;
+        if (transceiver.sendEncodingParameters[0].rtx) {
+          sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
+            ' ' + msid;
+          sdp += 'a=ssrc-group:FID ' +
+            transceiver.sendEncodingParameters[0].ssrc + ' ' +
+            transceiver.sendEncodingParameters[0].rtx.ssrc +
+            '\r\n';
+        }
+      }
+      // FIXME: this should be written by writeRtpDescription.
+      sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+        ' cname:' + SDPUtils.localCName + '\r\n';
+      if (transceiver.rtpSender && transceiver.sendEncodingParameters[0].rtx) {
+        sdp += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
+          ' cname:' + SDPUtils.localCName + '\r\n';
+      }
+      return sdp;
+    };
+
+    // Gets the direction from the mediaSection or the sessionpart.
+    SDPUtils.getDirection = function (mediaSection, sessionpart) {
+      // Look for sendrecv, sendonly, recvonly, inactive, default to sendrecv.
+      var lines = SDPUtils.splitLines(mediaSection);
+      for (var i = 0; i < lines.length; i++) {
+        switch (lines[i]) {
+          case 'a=sendrecv':
+          case 'a=sendonly':
+          case 'a=recvonly':
+          case 'a=inactive':
+            return lines[i].substr(2);
+          // FIXME: What should happen here?
+        }
+      }
+      if (sessionpart) {
+        return SDPUtils.getDirection(sessionpart);
+      }
+      return 'sendrecv';
+    };
+
+    SDPUtils.getKind = function (mediaSection) {
+      var lines = SDPUtils.splitLines(mediaSection);
+      var mline = lines[0].split(' ');
+      return mline[0].substr(2);
+    };
+
+    SDPUtils.isRejected = function (mediaSection) {
+      return mediaSection.split(' ', 2)[1] === '0';
+    };
+
+    SDPUtils.parseMLine = function (mediaSection) {
+      var lines = SDPUtils.splitLines(mediaSection);
+      var parts = lines[0].substr(2).split(' ');
+      return {
+        kind: parts[0],
+        port: parseInt(parts[1], 10),
+        protocol: parts[2],
+        fmt: parts.slice(3).join(' ')
+      };
+    };
+
+    SDPUtils.parseOLine = function (mediaSection) {
+      var line = SDPUtils.matchPrefix(mediaSection, 'o=')[0];
+      var parts = line.substr(2).split(' ');
+      return {
+        username: parts[0],
+        sessionId: parts[1],
+        sessionVersion: parseInt(parts[2], 10),
+        netType: parts[3],
+        addressType: parts[4],
+        address: parts[5]
+      };
+    };
+
+    // a very naive interpretation of a valid SDP.
+    SDPUtils.isValidSDP = function (blob) {
+      if (typeof blob !== 'string' || blob.length === 0) {
+        return false;
+      }
+      var lines = SDPUtils.splitLines(blob);
+      for (var i = 0; i < lines.length; i++) {
+        if (lines[i].length < 2 || lines[i].charAt(1) !== '=') {
+          return false;
+        }
+        // TODO: check the modifier a bit more.
+      }
+      return true;
+    };
+
+    // Expose public methods.
+    {
+      module.exports = SDPUtils;
+    }
+  });
+
+  /*
+	 *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+
+  function fixStatsType(stat) {
+    return {
+      inboundrtp: 'inbound-rtp',
+      outboundrtp: 'outbound-rtp',
+      candidatepair: 'candidate-pair',
+      localcandidate: 'local-candidate',
+      remotecandidate: 'remote-candidate'
+    }[stat.type] || stat.type;
+  }
+
+  function writeMediaSection(transceiver, caps, type, stream, dtlsRole) {
+    var sdp$1 = sdp.writeRtpDescription(transceiver.kind, caps);
+
+    // Map ICE parameters (ufrag, pwd) to SDP.
+    sdp$1 += sdp.writeIceParameters(
+      transceiver.iceGatherer.getLocalParameters());
+
+    // Map DTLS parameters to SDP.
+    sdp$1 += sdp.writeDtlsParameters(
+      transceiver.dtlsTransport.getLocalParameters(),
+      type === 'offer' ? 'actpass' : dtlsRole || 'active');
+
+    sdp$1 += 'a=mid:' + transceiver.mid + '\r\n';
+
+    if (transceiver.rtpSender && transceiver.rtpReceiver) {
+      sdp$1 += 'a=sendrecv\r\n';
+    } else if (transceiver.rtpSender) {
+      sdp$1 += 'a=sendonly\r\n';
+    } else if (transceiver.rtpReceiver) {
+      sdp$1 += 'a=recvonly\r\n';
+    } else {
+      sdp$1 += 'a=inactive\r\n';
+    }
+
+    if (transceiver.rtpSender) {
+      var trackId = transceiver.rtpSender._initialTrackId ||
+        transceiver.rtpSender.track.id;
+      transceiver.rtpSender._initialTrackId = trackId;
+      // spec.
+      var msid = 'msid:' + (stream ? stream.id : '-') + ' ' +
+        trackId + '\r\n';
+      sdp$1 += 'a=' + msid;
+      // for Chrome. Legacy should no longer be required.
+      sdp$1 += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+        ' ' + msid;
+
+      // RTX
+      if (transceiver.sendEncodingParameters[0].rtx) {
+        sdp$1 += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
+          ' ' + msid;
+        sdp$1 += 'a=ssrc-group:FID ' +
+          transceiver.sendEncodingParameters[0].ssrc + ' ' +
+          transceiver.sendEncodingParameters[0].rtx.ssrc +
+          '\r\n';
+      }
+    }
+    // FIXME: this should be written by writeRtpDescription.
+    sdp$1 += 'a=ssrc:' + transceiver.sendEncodingParameters[0].ssrc +
+      ' cname:' + sdp.localCName + '\r\n';
+    if (transceiver.rtpSender && transceiver.sendEncodingParameters[0].rtx) {
+      sdp$1 += 'a=ssrc:' + transceiver.sendEncodingParameters[0].rtx.ssrc +
+        ' cname:' + sdp.localCName + '\r\n';
+    }
+    return sdp$1;
+  }
+
+  // Edge does not like
+  // 1) stun: filtered after 14393 unless ?transport=udp is present
+  // 2) turn: that does not have all of turn:host:port?transport=udp
+  // 3) turn: with ipv6 addresses
+  // 4) turn: occurring muliple times
+  function filterIceServers(iceServers, edgeVersion) {
+    var hasTurn = false;
+    iceServers = JSON.parse(JSON.stringify(iceServers));
+    return iceServers.filter(function (server) {
+      if (server && (server.urls || server.url)) {
+        var urls = server.urls || server.url;
+        if (server.url && !server.urls) {
+          console.warn('RTCIceServer.url is deprecated! Use urls instead.');
+        }
+        var isString = typeof urls === 'string';
+        if (isString) {
+          urls = [urls];
+        }
+        urls = urls.filter(function (url) {
+          var validTurn = url.indexOf('turn:') === 0 &&
+            url.indexOf('transport=udp') !== -1 &&
+            url.indexOf('turn:[') === -1 &&
+            !hasTurn;
+
+          if (validTurn) {
+            hasTurn = true;
+            return true;
+          }
+          return url.indexOf('stun:') === 0 && edgeVersion >= 14393 &&
+            url.indexOf('?transport=udp') === -1;
+        });
+
+        delete server.url;
+        server.urls = isString ? urls[0] : urls;
+        return !!urls.length;
+      }
+    });
+  }
+
+  // Determines the intersection of local and remote capabilities.
+  function getCommonCapabilities(localCapabilities, remoteCapabilities) {
+    var commonCapabilities = {
+      codecs: [],
+      headerExtensions: [],
+      fecMechanisms: []
+    };
+
+    var findCodecByPayloadType = function (pt, codecs) {
+      pt = parseInt(pt, 10);
+      for (var i = 0; i < codecs.length; i++) {
+        if (codecs[i].payloadType === pt ||
+          codecs[i].preferredPayloadType === pt) {
+          return codecs[i];
+        }
+      }
+    };
+
+    var rtxCapabilityMatches = function (lRtx, rRtx, lCodecs, rCodecs) {
+      var lCodec = findCodecByPayloadType(lRtx.parameters.apt, lCodecs);
+      var rCodec = findCodecByPayloadType(rRtx.parameters.apt, rCodecs);
+      return lCodec && rCodec &&
+        lCodec.name.toLowerCase() === rCodec.name.toLowerCase();
+    };
+
+    localCapabilities.codecs.forEach(function (lCodec) {
+      for (var i = 0; i < remoteCapabilities.codecs.length; i++) {
+        var rCodec = remoteCapabilities.codecs[i];
+        if (lCodec.name.toLowerCase() === rCodec.name.toLowerCase() &&
+          lCodec.clockRate === rCodec.clockRate) {
+          if (lCodec.name.toLowerCase() === 'rtx' &&
+            lCodec.parameters && rCodec.parameters.apt) {
+            // for RTX we need to find the local rtx that has a apt
+            // which points to the same local codec as the remote one.
+            if (!rtxCapabilityMatches(lCodec, rCodec,
+              localCapabilities.codecs, remoteCapabilities.codecs)) {
+              continue;
+            }
+          }
+          rCodec = JSON.parse(JSON.stringify(rCodec)); // deepcopy
+          // number of channels is the highest common number of channels
+          rCodec.numChannels = Math.min(lCodec.numChannels,
+            rCodec.numChannels);
+          // push rCodec so we reply with offerer payload type
+          commonCapabilities.codecs.push(rCodec);
+
+          // determine common feedback mechanisms
+          rCodec.rtcpFeedback = rCodec.rtcpFeedback.filter(function (fb) {
+            for (var j = 0; j < lCodec.rtcpFeedback.length; j++) {
+              if (lCodec.rtcpFeedback[j].type === fb.type &&
+                lCodec.rtcpFeedback[j].parameter === fb.parameter) {
+                return true;
+              }
+            }
+            return false;
+          });
+          // FIXME: also need to determine .parameters
+          //  see https://github.com/openpeer/ortc/issues/569
+          break;
+        }
+      }
+    });
+
+    localCapabilities.headerExtensions.forEach(function (lHeaderExtension) {
+      for (var i = 0; i < remoteCapabilities.headerExtensions.length;
+           i++) {
+        var rHeaderExtension = remoteCapabilities.headerExtensions[i];
+        if (lHeaderExtension.uri === rHeaderExtension.uri) {
+          commonCapabilities.headerExtensions.push(rHeaderExtension);
+          break;
+        }
+      }
+    });
+
+    // FIXME: fecMechanisms
+    return commonCapabilities;
+  }
+
+  // is action=setLocalDescription with type allowed in signalingState
+  function isActionAllowedInSignalingState(action, type, signalingState) {
+    return {
+      offer: {
+        setLocalDescription: ['stable', 'have-local-offer'],
+        setRemoteDescription: ['stable', 'have-remote-offer']
+      },
+      answer: {
+        setLocalDescription: ['have-remote-offer', 'have-local-pranswer'],
+        setRemoteDescription: ['have-local-offer', 'have-remote-pranswer']
+      }
+    }[type][action].indexOf(signalingState) !== -1;
+  }
+
+  function maybeAddCandidate(iceTransport, candidate) {
+    // Edge's internal representation adds some fields therefore
+    // not all fieldѕ are taken into account.
+    var alreadyAdded = iceTransport.getRemoteCandidates()
+      .find(function (remoteCandidate) {
+        return candidate.foundation === remoteCandidate.foundation &&
+          candidate.ip === remoteCandidate.ip &&
+          candidate.port === remoteCandidate.port &&
+          candidate.priority === remoteCandidate.priority &&
+          candidate.protocol === remoteCandidate.protocol &&
+          candidate.type === remoteCandidate.type;
+      });
+    if (!alreadyAdded) {
+      iceTransport.addRemoteCandidate(candidate);
+    }
+    return !alreadyAdded;
+  }
+
+
+  function makeError(name, description) {
+    var e = new Error(description);
+    e.name = name;
+    // legacy error codes from https://heycam.github.io/webidl/#idl-DOMException-error-names
+    e.code = {
+      NotSupportedError: 9,
+      InvalidStateError: 11,
+      InvalidAccessError: 15,
+      TypeError: undefined,
+      OperationError: undefined
+    }[name];
+    return e;
+  }
+
+  var rtcpeerconnection = function (window, edgeVersion) {
+    // https://w3c.github.io/mediacapture-main/#mediastream
+    // Helper function to add the track to the stream and
+    // dispatch the event ourselves.
+    function addTrackToStreamAndFireEvent(track, stream) {
+      stream.addTrack(track);
+      stream.dispatchEvent(new window.MediaStreamTrackEvent('addtrack',
+        {track: track}));
+    }
+
+    function removeTrackFromStreamAndFireEvent(track, stream) {
+      stream.removeTrack(track);
+      stream.dispatchEvent(new window.MediaStreamTrackEvent('removetrack',
+        {track: track}));
+    }
+
+    function fireAddTrack(pc, track, receiver, streams) {
+      var trackEvent = new Event('track');
+      trackEvent.track = track;
+      trackEvent.receiver = receiver;
+      trackEvent.transceiver = {receiver: receiver};
+      trackEvent.streams = streams;
+      window.setTimeout(function () {
+        pc._dispatchEvent('track', trackEvent);
+      });
+    }
+
+    var RTCPeerConnection = function (config) {
+      var pc = this;
+
+      var _eventTarget = document.createDocumentFragment();
+      ['addEventListener', 'removeEventListener', 'dispatchEvent']
+        .forEach(function (method) {
+          pc[method] = _eventTarget[method].bind(_eventTarget);
+        });
+
+      this.canTrickleIceCandidates = null;
+
+      this.needNegotiation = false;
+
+      this.localStreams = [];
+      this.remoteStreams = [];
+
+      this._localDescription = null;
+      this._remoteDescription = null;
+
+      this.signalingState = 'stable';
+      this.iceConnectionState = 'new';
+      this.connectionState = 'new';
+      this.iceGatheringState = 'new';
+
+      config = JSON.parse(JSON.stringify(config || {}));
+
+      this.usingBundle = config.bundlePolicy === 'max-bundle';
+      if (config.rtcpMuxPolicy === 'negotiate') {
+        throw(makeError('NotSupportedError',
+          'rtcpMuxPolicy \'negotiate\' is not supported'));
+      } else if (!config.rtcpMuxPolicy) {
+        config.rtcpMuxPolicy = 'require';
+      }
+
+      switch (config.iceTransportPolicy) {
+        case 'all':
+        case 'relay':
+          break;
+        default:
+          config.iceTransportPolicy = 'all';
+          break;
+      }
+
+      switch (config.bundlePolicy) {
+        case 'balanced':
+        case 'max-compat':
+        case 'max-bundle':
+          break;
+        default:
+          config.bundlePolicy = 'balanced';
+          break;
+      }
+
+      config.iceServers = filterIceServers(config.iceServers || [], edgeVersion);
+
+      this._iceGatherers = [];
+      if (config.iceCandidatePoolSize) {
+        for (var i = config.iceCandidatePoolSize; i > 0; i--) {
+          this._iceGatherers.push(new window.RTCIceGatherer({
+            iceServers: config.iceServers,
+            gatherPolicy: config.iceTransportPolicy
+          }));
+        }
+      } else {
+        config.iceCandidatePoolSize = 0;
+      }
+
+      this._config = config;
+
+      // per-track iceGathers, iceTransports, dtlsTransports, rtpSenders, ...
+      // everything that is needed to describe a SDP m-line.
+      this.transceivers = [];
+
+      this._sdpSessionId = sdp.generateSessionId();
+      this._sdpSessionVersion = 0;
+
+      this._dtlsRole = undefined; // role for a=setup to use in answers.
+
+      this._isClosed = false;
+    };
+
+    Object.defineProperty(RTCPeerConnection.prototype, 'localDescription', {
+      configurable: true,
+      get: function () {
+        return this._localDescription;
+      }
+    });
+    Object.defineProperty(RTCPeerConnection.prototype, 'remoteDescription', {
+      configurable: true,
+      get: function () {
+        return this._remoteDescription;
+      }
+    });
+
+    // set up event handlers on prototype
+    RTCPeerConnection.prototype.onicecandidate = null;
+    RTCPeerConnection.prototype.onaddstream = null;
+    RTCPeerConnection.prototype.ontrack = null;
+    RTCPeerConnection.prototype.onremovestream = null;
+    RTCPeerConnection.prototype.onsignalingstatechange = null;
+    RTCPeerConnection.prototype.oniceconnectionstatechange = null;
+    RTCPeerConnection.prototype.onconnectionstatechange = null;
+    RTCPeerConnection.prototype.onicegatheringstatechange = null;
+    RTCPeerConnection.prototype.onnegotiationneeded = null;
+    RTCPeerConnection.prototype.ondatachannel = null;
+
+    RTCPeerConnection.prototype._dispatchEvent = function (name, event) {
+      if (this._isClosed) {
+        return;
+      }
+      this.dispatchEvent(event);
+      if (typeof this['on' + name] === 'function') {
+        this['on' + name](event);
+      }
+    };
+
+    RTCPeerConnection.prototype._emitGatheringStateChange = function () {
+      var event = new Event('icegatheringstatechange');
+      this._dispatchEvent('icegatheringstatechange', event);
+    };
+
+    RTCPeerConnection.prototype.getConfiguration = function () {
+      return this._config;
+    };
+
+    RTCPeerConnection.prototype.getLocalStreams = function () {
+      return this.localStreams;
+    };
+
+    RTCPeerConnection.prototype.getRemoteStreams = function () {
+      return this.remoteStreams;
+    };
+
+    // internal helper to create a transceiver object.
+    // (which is not yet the same as the WebRTC 1.0 transceiver)
+    RTCPeerConnection.prototype._createTransceiver = function (kind, doNotAdd) {
+      var hasBundleTransport = this.transceivers.length > 0;
+      var transceiver = {
+        track: null,
+        iceGatherer: null,
+        iceTransport: null,
+        dtlsTransport: null,
+        localCapabilities: null,
+        remoteCapabilities: null,
+        rtpSender: null,
+        rtpReceiver: null,
+        kind: kind,
+        mid: null,
+        sendEncodingParameters: null,
+        recvEncodingParameters: null,
+        stream: null,
+        associatedRemoteMediaStreams: [],
+        wantReceive: true
+      };
+      if (this.usingBundle && hasBundleTransport) {
+        transceiver.iceTransport = this.transceivers[0].iceTransport;
+        transceiver.dtlsTransport = this.transceivers[0].dtlsTransport;
+      } else {
+        var transports = this._createIceAndDtlsTransports();
+        transceiver.iceTransport = transports.iceTransport;
+        transceiver.dtlsTransport = transports.dtlsTransport;
+      }
+      if (!doNotAdd) {
+        this.transceivers.push(transceiver);
+      }
+      return transceiver;
+    };
+
+    RTCPeerConnection.prototype.addTrack = function (track, stream) {
+      if (this._isClosed) {
+        throw makeError('InvalidStateError',
+          'Attempted to call addTrack on a closed peerconnection.');
+      }
+
+      var alreadyExists = this.transceivers.find(function (s) {
+        return s.track === track;
+      });
+
+      if (alreadyExists) {
+        throw makeError('InvalidAccessError', 'Track already exists.');
+      }
+
+      var transceiver;
+      for (var i = 0; i < this.transceivers.length; i++) {
+        if (!this.transceivers[i].track &&
+          this.transceivers[i].kind === track.kind) {
+          transceiver = this.transceivers[i];
+        }
+      }
+      if (!transceiver) {
+        transceiver = this._createTransceiver(track.kind);
+      }
+
+      this._maybeFireNegotiationNeeded();
+
+      if (this.localStreams.indexOf(stream) === -1) {
+        this.localStreams.push(stream);
+      }
+
+      transceiver.track = track;
+      transceiver.stream = stream;
+      transceiver.rtpSender = new window.RTCRtpSender(track,
+        transceiver.dtlsTransport);
+      return transceiver.rtpSender;
+    };
+
+    RTCPeerConnection.prototype.addStream = function (stream) {
+      var pc = this;
+      if (edgeVersion >= 15025) {
+        stream.getTracks().forEach(function (track) {
+          pc.addTrack(track, stream);
+        });
+      } else {
+        // Clone is necessary for local demos mostly, attaching directly
+        // to two different senders does not work (build 10547).
+        // Fixed in 15025 (or earlier)
+        var clonedStream = stream.clone();
+        stream.getTracks().forEach(function (track, idx) {
+          var clonedTrack = clonedStream.getTracks()[idx];
+          track.addEventListener('enabled', function (event) {
+            clonedTrack.enabled = event.enabled;
+          });
+        });
+        clonedStream.getTracks().forEach(function (track) {
+          pc.addTrack(track, clonedStream);
+        });
+      }
+    };
+
+    RTCPeerConnection.prototype.removeTrack = function (sender) {
+      if (this._isClosed) {
+        throw makeError('InvalidStateError',
+          'Attempted to call removeTrack on a closed peerconnection.');
+      }
+
+      if (!(sender instanceof window.RTCRtpSender)) {
+        throw new TypeError('Argument 1 of RTCPeerConnection.removeTrack ' +
+          'does not implement interface RTCRtpSender.');
+      }
+
+      var transceiver = this.transceivers.find(function (t) {
+        return t.rtpSender === sender;
+      });
+
+      if (!transceiver) {
+        throw makeError('InvalidAccessError',
+          'Sender was not created by this connection.');
+      }
+      var stream = transceiver.stream;
+
+      transceiver.rtpSender.stop();
+      transceiver.rtpSender = null;
+      transceiver.track = null;
+      transceiver.stream = null;
+
+      // remove the stream from the set of local streams
+      var localStreams = this.transceivers.map(function (t) {
+        return t.stream;
+      });
+      if (localStreams.indexOf(stream) === -1 &&
+        this.localStreams.indexOf(stream) > -1) {
+        this.localStreams.splice(this.localStreams.indexOf(stream), 1);
+      }
+
+      this._maybeFireNegotiationNeeded();
+    };
+
+    RTCPeerConnection.prototype.removeStream = function (stream) {
+      var pc = this;
+      stream.getTracks().forEach(function (track) {
+        var sender = pc.getSenders().find(function (s) {
+          return s.track === track;
+        });
+        if (sender) {
+          pc.removeTrack(sender);
+        }
+      });
+    };
+
+    RTCPeerConnection.prototype.getSenders = function () {
+      return this.transceivers.filter(function (transceiver) {
+        return !!transceiver.rtpSender;
+      })
+        .map(function (transceiver) {
+          return transceiver.rtpSender;
+        });
+    };
+
+    RTCPeerConnection.prototype.getReceivers = function () {
+      return this.transceivers.filter(function (transceiver) {
+        return !!transceiver.rtpReceiver;
+      })
+        .map(function (transceiver) {
+          return transceiver.rtpReceiver;
+        });
+    };
+
+
+    RTCPeerConnection.prototype._createIceGatherer = function (sdpMLineIndex,
+                                                               usingBundle) {
+      var pc = this;
+      if (usingBundle && sdpMLineIndex > 0) {
+        return this.transceivers[0].iceGatherer;
+      } else if (this._iceGatherers.length) {
+        return this._iceGatherers.shift();
+      }
+      var iceGatherer = new window.RTCIceGatherer({
+        iceServers: this._config.iceServers,
+        gatherPolicy: this._config.iceTransportPolicy
+      });
+      Object.defineProperty(iceGatherer, 'state',
+        {value: 'new', writable: true}
+      );
+
+      this.transceivers[sdpMLineIndex].bufferedCandidateEvents = [];
+      this.transceivers[sdpMLineIndex].bufferCandidates = function (event) {
+        var end = !event.candidate || Object.keys(event.candidate).length === 0;
+        // polyfill since RTCIceGatherer.state is not implemented in
+        // Edge 10547 yet.
+        iceGatherer.state = end ? 'completed' : 'gathering';
+        if (pc.transceivers[sdpMLineIndex].bufferedCandidateEvents !== null) {
+          pc.transceivers[sdpMLineIndex].bufferedCandidateEvents.push(event);
+        }
+      };
+      iceGatherer.addEventListener('localcandidate',
+        this.transceivers[sdpMLineIndex].bufferCandidates);
+      return iceGatherer;
+    };
+
+    // start gathering from an RTCIceGatherer.
+    RTCPeerConnection.prototype._gather = function (mid, sdpMLineIndex) {
+      var pc = this;
+      var iceGatherer = this.transceivers[sdpMLineIndex].iceGatherer;
+      if (iceGatherer.onlocalcandidate) {
+        return;
+      }
+      var bufferedCandidateEvents =
+        this.transceivers[sdpMLineIndex].bufferedCandidateEvents;
+      this.transceivers[sdpMLineIndex].bufferedCandidateEvents = null;
+      iceGatherer.removeEventListener('localcandidate',
+        this.transceivers[sdpMLineIndex].bufferCandidates);
+      iceGatherer.onlocalcandidate = function (evt) {
+        if (pc.usingBundle && sdpMLineIndex > 0) {
+          // if we know that we use bundle we can drop candidates with
+          // ѕdpMLineIndex > 0. If we don't do this then our state gets
+          // confused since we dispose the extra ice gatherer.
+          return;
+        }
+        var event = new Event('icecandidate');
+        event.candidate = {sdpMid: mid, sdpMLineIndex: sdpMLineIndex};
+
+        var cand = evt.candidate;
+        // Edge emits an empty object for RTCIceCandidateComplete‥
+        var end = !cand || Object.keys(cand).length === 0;
+        if (end) {
+          // polyfill since RTCIceGatherer.state is not implemented in
+          // Edge 10547 yet.
+          if (iceGatherer.state === 'new' || iceGatherer.state === 'gathering') {
+            iceGatherer.state = 'completed';
+          }
+        } else {
+          if (iceGatherer.state === 'new') {
+            iceGatherer.state = 'gathering';
+          }
+          // RTCIceCandidate doesn't have a component, needs to be added
+          cand.component = 1;
+          // also the usernameFragment. TODO: update SDP to take both variants.
+          cand.ufrag = iceGatherer.getLocalParameters().usernameFragment;
+
+          var serializedCandidate = sdp.writeCandidate(cand);
+          event.candidate = Object.assign(event.candidate,
+            sdp.parseCandidate(serializedCandidate));
+
+          event.candidate.candidate = serializedCandidate;
+          event.candidate.toJSON = function () {
+            return {
+              candidate: event.candidate.candidate,
+              sdpMid: event.candidate.sdpMid,
+              sdpMLineIndex: event.candidate.sdpMLineIndex,
+              usernameFragment: event.candidate.usernameFragment
+            };
+          };
+        }
+
+        // update local description.
+        var sections = sdp.getMediaSections(pc._localDescription.sdp);
+        if (!end) {
+          sections[event.candidate.sdpMLineIndex] +=
+            'a=' + event.candidate.candidate + '\r\n';
+        } else {
+          sections[event.candidate.sdpMLineIndex] +=
+            'a=end-of-candidates\r\n';
+        }
+        pc._localDescription.sdp =
+          sdp.getDescription(pc._localDescription.sdp) +
+          sections.join('');
+        var complete = pc.transceivers.every(function (transceiver) {
+          return transceiver.iceGatherer &&
+            transceiver.iceGatherer.state === 'completed';
+        });
+
+        if (pc.iceGatheringState !== 'gathering') {
+          pc.iceGatheringState = 'gathering';
+          pc._emitGatheringStateChange();
+        }
+
+        // Emit candidate. Also emit null candidate when all gatherers are
+        // complete.
+        if (!end) {
+          pc._dispatchEvent('icecandidate', event);
+        }
+        if (complete) {
+          pc._dispatchEvent('icecandidate', new Event('icecandidate'));
+          pc.iceGatheringState = 'complete';
+          pc._emitGatheringStateChange();
+        }
+      };
+
+      // emit already gathered candidates.
+      window.setTimeout(function () {
+        bufferedCandidateEvents.forEach(function (e) {
+          iceGatherer.onlocalcandidate(e);
+        });
+      }, 0);
+    };
+
+    // Create ICE transport and DTLS transport.
+    RTCPeerConnection.prototype._createIceAndDtlsTransports = function () {
+      var pc = this;
+      var iceTransport = new window.RTCIceTransport(null);
+      iceTransport.onicestatechange = function () {
+        pc._updateIceConnectionState();
+        pc._updateConnectionState();
+      };
+
+      var dtlsTransport = new window.RTCDtlsTransport(iceTransport);
+      dtlsTransport.ondtlsstatechange = function () {
+        pc._updateConnectionState();
+      };
+      dtlsTransport.onerror = function () {
+        // onerror does not set state to failed by itself.
+        Object.defineProperty(dtlsTransport, 'state',
+          {value: 'failed', writable: true});
+        pc._updateConnectionState();
+      };
+
+      return {
+        iceTransport: iceTransport,
+        dtlsTransport: dtlsTransport
+      };
+    };
+
+    // Destroy ICE gatherer, ICE transport and DTLS transport.
+    // Without triggering the callbacks.
+    RTCPeerConnection.prototype._disposeIceAndDtlsTransports = function (
+      sdpMLineIndex) {
+      var iceGatherer = this.transceivers[sdpMLineIndex].iceGatherer;
+      if (iceGatherer) {
+        delete iceGatherer.onlocalcandidate;
+        delete this.transceivers[sdpMLineIndex].iceGatherer;
+      }
+      var iceTransport = this.transceivers[sdpMLineIndex].iceTransport;
+      if (iceTransport) {
+        delete iceTransport.onicestatechange;
+        delete this.transceivers[sdpMLineIndex].iceTransport;
+      }
+      var dtlsTransport = this.transceivers[sdpMLineIndex].dtlsTransport;
+      if (dtlsTransport) {
+        delete dtlsTransport.ondtlsstatechange;
+        delete dtlsTransport.onerror;
+        delete this.transceivers[sdpMLineIndex].dtlsTransport;
+      }
+    };
+
+    // Start the RTP Sender and Receiver for a transceiver.
+    RTCPeerConnection.prototype._transceive = function (transceiver,
+                                                        send, recv) {
+      var params = getCommonCapabilities(transceiver.localCapabilities,
+        transceiver.remoteCapabilities);
+      if (send && transceiver.rtpSender) {
+        params.encodings = transceiver.sendEncodingParameters;
+        params.rtcp = {
+          cname: sdp.localCName,
+          compound: transceiver.rtcpParameters.compound
+        };
+        if (transceiver.recvEncodingParameters.length) {
+          params.rtcp.ssrc = transceiver.recvEncodingParameters[0].ssrc;
+        }
+        transceiver.rtpSender.send(params);
+      }
+      if (recv && transceiver.rtpReceiver && params.codecs.length > 0) {
+        // remove RTX field in Edge 14942
+        if (transceiver.kind === 'video'
+          && transceiver.recvEncodingParameters
+          && edgeVersion < 15019) {
+          transceiver.recvEncodingParameters.forEach(function (p) {
+            delete p.rtx;
+          });
+        }
+        if (transceiver.recvEncodingParameters.length) {
+          params.encodings = transceiver.recvEncodingParameters;
+        } else {
+          params.encodings = [{}];
+        }
+        params.rtcp = {
+          compound: transceiver.rtcpParameters.compound
+        };
+        if (transceiver.rtcpParameters.cname) {
+          params.rtcp.cname = transceiver.rtcpParameters.cname;
+        }
+        if (transceiver.sendEncodingParameters.length) {
+          params.rtcp.ssrc = transceiver.sendEncodingParameters[0].ssrc;
+        }
+        transceiver.rtpReceiver.receive(params);
+      }
+    };
+
+    RTCPeerConnection.prototype.setLocalDescription = function (description) {
+      var pc = this;
+
+      // Note: pranswer is not supported.
+      if (['offer', 'answer'].indexOf(description.type) === -1) {
+        return Promise.reject(makeError('TypeError',
+          'Unsupported type "' + description.type + '"'));
+      }
+
+      if (!isActionAllowedInSignalingState('setLocalDescription',
+        description.type, pc.signalingState) || pc._isClosed) {
+        return Promise.reject(makeError('InvalidStateError',
+          'Can not set local ' + description.type +
+          ' in state ' + pc.signalingState));
+      }
+
+      var sections;
+      var sessionpart;
+      if (description.type === 'offer') {
+        // VERY limited support for SDP munging. Limited to:
+        // * changing the order of codecs
+        sections = sdp.splitSections(description.sdp);
+        sessionpart = sections.shift();
+        sections.forEach(function (mediaSection, sdpMLineIndex) {
+          var caps = sdp.parseRtpParameters(mediaSection);
+          pc.transceivers[sdpMLineIndex].localCapabilities = caps;
+        });
+
+        pc.transceivers.forEach(function (transceiver, sdpMLineIndex) {
+          pc._gather(transceiver.mid, sdpMLineIndex);
+        });
+      } else if (description.type === 'answer') {
+        sections = sdp.splitSections(pc._remoteDescription.sdp);
+        sessionpart = sections.shift();
+        var isIceLite = sdp.matchPrefix(sessionpart,
+          'a=ice-lite').length > 0;
+        sections.forEach(function (mediaSection, sdpMLineIndex) {
+          var transceiver = pc.transceivers[sdpMLineIndex];
+          var iceGatherer = transceiver.iceGatherer;
+          var iceTransport = transceiver.iceTransport;
+          var dtlsTransport = transceiver.dtlsTransport;
+          var localCapabilities = transceiver.localCapabilities;
+          var remoteCapabilities = transceiver.remoteCapabilities;
+
+          // treat bundle-only as not-rejected.
+          var rejected = sdp.isRejected(mediaSection) &&
+            sdp.matchPrefix(mediaSection, 'a=bundle-only').length === 0;
+
+          if (!rejected && !transceiver.rejected) {
+            var remoteIceParameters = sdp.getIceParameters(
+              mediaSection, sessionpart);
+            var remoteDtlsParameters = sdp.getDtlsParameters(
+              mediaSection, sessionpart);
+            if (isIceLite) {
+              remoteDtlsParameters.role = 'server';
+            }
+
+            if (!pc.usingBundle || sdpMLineIndex === 0) {
+              pc._gather(transceiver.mid, sdpMLineIndex);
+              if (iceTransport.state === 'new') {
+                iceTransport.start(iceGatherer, remoteIceParameters,
+                  isIceLite ? 'controlling' : 'controlled');
+              }
+              if (dtlsTransport.state === 'new') {
+                dtlsTransport.start(remoteDtlsParameters);
+              }
+            }
+
+            // Calculate intersection of capabilities.
+            var params = getCommonCapabilities(localCapabilities,
+              remoteCapabilities);
+
+            // Start the RTCRtpSender. The RTCRtpReceiver for this
+            // transceiver has already been started in setRemoteDescription.
+            pc._transceive(transceiver,
+              params.codecs.length > 0,
+              false);
+          }
+        });
+      }
+
+      pc._localDescription = {
+        type: description.type,
+        sdp: description.sdp
+      };
+      if (description.type === 'offer') {
+        pc._updateSignalingState('have-local-offer');
+      } else {
+        pc._updateSignalingState('stable');
+      }
+
+      return Promise.resolve();
+    };
+
+    RTCPeerConnection.prototype.setRemoteDescription = function (description) {
+      var pc = this;
+
+      // Note: pranswer is not supported.
+      if (['offer', 'answer'].indexOf(description.type) === -1) {
+        return Promise.reject(makeError('TypeError',
+          'Unsupported type "' + description.type + '"'));
+      }
+
+      if (!isActionAllowedInSignalingState('setRemoteDescription',
+        description.type, pc.signalingState) || pc._isClosed) {
+        return Promise.reject(makeError('InvalidStateError',
+          'Can not set remote ' + description.type +
+          ' in state ' + pc.signalingState));
+      }
+
+      var streams = {};
+      pc.remoteStreams.forEach(function (stream) {
+        streams[stream.id] = stream;
+      });
+      var receiverList = [];
+      var sections = sdp.splitSections(description.sdp);
+      var sessionpart = sections.shift();
+      var isIceLite = sdp.matchPrefix(sessionpart,
+        'a=ice-lite').length > 0;
+      var usingBundle = sdp.matchPrefix(sessionpart,
+        'a=group:BUNDLE ').length > 0;
+      pc.usingBundle = usingBundle;
+      var iceOptions = sdp.matchPrefix(sessionpart,
+        'a=ice-options:')[0];
+      if (iceOptions) {
+        pc.canTrickleIceCandidates = iceOptions.substr(14).split(' ')
+          .indexOf('trickle') >= 0;
+      } else {
+        pc.canTrickleIceCandidates = false;
+      }
+
+      sections.forEach(function (mediaSection, sdpMLineIndex) {
+        var lines = sdp.splitLines(mediaSection);
+        var kind = sdp.getKind(mediaSection);
+        // treat bundle-only as not-rejected.
+        var rejected = sdp.isRejected(mediaSection) &&
+          sdp.matchPrefix(mediaSection, 'a=bundle-only').length === 0;
+        var protocol = lines[0].substr(2).split(' ')[2];
+
+        var direction = sdp.getDirection(mediaSection, sessionpart);
+        var remoteMsid = sdp.parseMsid(mediaSection);
+
+        var mid = sdp.getMid(mediaSection) || sdp.generateIdentifier();
+
+        // Reject datachannels which are not implemented yet.
+        if (rejected || (kind === 'application' && (protocol === 'DTLS/SCTP' ||
+          protocol === 'UDP/DTLS/SCTP'))) {
+          // TODO: this is dangerous in the case where a non-rejected m-line
+          //     becomes rejected.
+          pc.transceivers[sdpMLineIndex] = {
+            mid: mid,
+            kind: kind,
+            protocol: protocol,
+            rejected: true
+          };
+          return;
+        }
+
+        if (!rejected && pc.transceivers[sdpMLineIndex] &&
+          pc.transceivers[sdpMLineIndex].rejected) {
+          // recycle a rejected transceiver.
+          pc.transceivers[sdpMLineIndex] = pc._createTransceiver(kind, true);
+        }
+
+        var transceiver;
+        var iceGatherer;
+        var iceTransport;
+        var dtlsTransport;
+        var rtpReceiver;
+        var sendEncodingParameters;
+        var recvEncodingParameters;
+        var localCapabilities;
+
+        var track;
+        // FIXME: ensure the mediaSection has rtcp-mux set.
+        var remoteCapabilities = sdp.parseRtpParameters(mediaSection);
+        var remoteIceParameters;
+        var remoteDtlsParameters;
+        if (!rejected) {
+          remoteIceParameters = sdp.getIceParameters(mediaSection,
+            sessionpart);
+          remoteDtlsParameters = sdp.getDtlsParameters(mediaSection,
+            sessionpart);
+          remoteDtlsParameters.role = 'client';
+        }
+        recvEncodingParameters =
+          sdp.parseRtpEncodingParameters(mediaSection);
+
+        var rtcpParameters = sdp.parseRtcpParameters(mediaSection);
+
+        var isComplete = sdp.matchPrefix(mediaSection,
+          'a=end-of-candidates', sessionpart).length > 0;
+        var cands = sdp.matchPrefix(mediaSection, 'a=candidate:')
+          .map(function (cand) {
+            return sdp.parseCandidate(cand);
+          })
+          .filter(function (cand) {
+            return cand.component === 1;
+          });
+
+        // Check if we can use BUNDLE and dispose transports.
+        if ((description.type === 'offer' || description.type === 'answer') &&
+          !rejected && usingBundle && sdpMLineIndex > 0 &&
+          pc.transceivers[sdpMLineIndex]) {
+          pc._disposeIceAndDtlsTransports(sdpMLineIndex);
+          pc.transceivers[sdpMLineIndex].iceGatherer =
+            pc.transceivers[0].iceGatherer;
+          pc.transceivers[sdpMLineIndex].iceTransport =
+            pc.transceivers[0].iceTransport;
+          pc.transceivers[sdpMLineIndex].dtlsTransport =
+            pc.transceivers[0].dtlsTransport;
+          if (pc.transceivers[sdpMLineIndex].rtpSender) {
+            pc.transceivers[sdpMLineIndex].rtpSender.setTransport(
+              pc.transceivers[0].dtlsTransport);
+          }
+          if (pc.transceivers[sdpMLineIndex].rtpReceiver) {
+            pc.transceivers[sdpMLineIndex].rtpReceiver.setTransport(
+              pc.transceivers[0].dtlsTransport);
+          }
+        }
+        if (description.type === 'offer' && !rejected) {
+          transceiver = pc.transceivers[sdpMLineIndex] ||
+            pc._createTransceiver(kind);
+          transceiver.mid = mid;
+
+          if (!transceiver.iceGatherer) {
+            transceiver.iceGatherer = pc._createIceGatherer(sdpMLineIndex,
+              usingBundle);
+          }
+
+          if (cands.length && transceiver.iceTransport.state === 'new') {
+            if (isComplete && (!usingBundle || sdpMLineIndex === 0)) {
+              transceiver.iceTransport.setRemoteCandidates(cands);
+            } else {
+              cands.forEach(function (candidate) {
+                maybeAddCandidate(transceiver.iceTransport, candidate);
+              });
+            }
+          }
+
+          localCapabilities = window.RTCRtpReceiver.getCapabilities(kind);
+
+          // filter RTX until additional stuff needed for RTX is implemented
+          // in adapter.js
+          if (edgeVersion < 15019) {
+            localCapabilities.codecs = localCapabilities.codecs.filter(
+              function (codec) {
+                return codec.name !== 'rtx';
+              });
+          }
+
+          sendEncodingParameters = transceiver.sendEncodingParameters || [{
+            ssrc: (2 * sdpMLineIndex + 2) * 1001
+          }];
+
+          // TODO: rewrite to use http://w3c.github.io/webrtc-pc/#set-associated-remote-streams
+          var isNewTrack = false;
+          if (direction === 'sendrecv' || direction === 'sendonly') {
+            isNewTrack = !transceiver.rtpReceiver;
+            rtpReceiver = transceiver.rtpReceiver ||
+              new window.RTCRtpReceiver(transceiver.dtlsTransport, kind);
+
+            if (isNewTrack) {
+              var stream;
+              track = rtpReceiver.track;
+              // FIXME: does not work with Plan B.
+              if (remoteMsid && remoteMsid.stream === '-') ; else if (remoteMsid) {
+                if (!streams[remoteMsid.stream]) {
+                  streams[remoteMsid.stream] = new window.MediaStream();
+                  Object.defineProperty(streams[remoteMsid.stream], 'id', {
+                    get: function () {
+                      return remoteMsid.stream;
+                    }
+                  });
+                }
+                Object.defineProperty(track, 'id', {
+                  get: function () {
+                    return remoteMsid.track;
+                  }
+                });
+                stream = streams[remoteMsid.stream];
+              } else {
+                if (!streams.default) {
+                  streams.default = new window.MediaStream();
+                }
+                stream = streams.default;
+              }
+              if (stream) {
+                addTrackToStreamAndFireEvent(track, stream);
+                transceiver.associatedRemoteMediaStreams.push(stream);
+              }
+              receiverList.push([track, rtpReceiver, stream]);
+            }
+          } else if (transceiver.rtpReceiver && transceiver.rtpReceiver.track) {
+            transceiver.associatedRemoteMediaStreams.forEach(function (s) {
+              var nativeTrack = s.getTracks().find(function (t) {
+                return t.id === transceiver.rtpReceiver.track.id;
+              });
+              if (nativeTrack) {
+                removeTrackFromStreamAndFireEvent(nativeTrack, s);
+              }
+            });
+            transceiver.associatedRemoteMediaStreams = [];
+          }
+
+          transceiver.localCapabilities = localCapabilities;
+          transceiver.remoteCapabilities = remoteCapabilities;
+          transceiver.rtpReceiver = rtpReceiver;
+          transceiver.rtcpParameters = rtcpParameters;
+          transceiver.sendEncodingParameters = sendEncodingParameters;
+          transceiver.recvEncodingParameters = recvEncodingParameters;
+
+          // Start the RTCRtpReceiver now. The RTPSender is started in
+          // setLocalDescription.
+          pc._transceive(pc.transceivers[sdpMLineIndex],
+            false,
+            isNewTrack);
+        } else if (description.type === 'answer' && !rejected) {
+          transceiver = pc.transceivers[sdpMLineIndex];
+          iceGatherer = transceiver.iceGatherer;
+          iceTransport = transceiver.iceTransport;
+          dtlsTransport = transceiver.dtlsTransport;
+          rtpReceiver = transceiver.rtpReceiver;
+          sendEncodingParameters = transceiver.sendEncodingParameters;
+          localCapabilities = transceiver.localCapabilities;
+
+          pc.transceivers[sdpMLineIndex].recvEncodingParameters =
+            recvEncodingParameters;
+          pc.transceivers[sdpMLineIndex].remoteCapabilities =
+            remoteCapabilities;
+          pc.transceivers[sdpMLineIndex].rtcpParameters = rtcpParameters;
+
+          if (cands.length && iceTransport.state === 'new') {
+            if ((isIceLite || isComplete) &&
+              (!usingBundle || sdpMLineIndex === 0)) {
+              iceTransport.setRemoteCandidates(cands);
+            } else {
+              cands.forEach(function (candidate) {
+                maybeAddCandidate(transceiver.iceTransport, candidate);
+              });
+            }
+          }
+
+          if (!usingBundle || sdpMLineIndex === 0) {
+            if (iceTransport.state === 'new') {
+              iceTransport.start(iceGatherer, remoteIceParameters,
+                'controlling');
+            }
+            if (dtlsTransport.state === 'new') {
+              dtlsTransport.start(remoteDtlsParameters);
+            }
+          }
+
+          // If the offer contained RTX but the answer did not,
+          // remove RTX from sendEncodingParameters.
+          var commonCapabilities = getCommonCapabilities(
+            transceiver.localCapabilities,
+            transceiver.remoteCapabilities);
+
+          var hasRtx = commonCapabilities.codecs.filter(function (c) {
+            return c.name.toLowerCase() === 'rtx';
+          }).length;
+          if (!hasRtx && transceiver.sendEncodingParameters[0].rtx) {
+            delete transceiver.sendEncodingParameters[0].rtx;
+          }
+
+          pc._transceive(transceiver,
+            direction === 'sendrecv' || direction === 'recvonly',
+            direction === 'sendrecv' || direction === 'sendonly');
+
+          // TODO: rewrite to use http://w3c.github.io/webrtc-pc/#set-associated-remote-streams
+          if (rtpReceiver &&
+            (direction === 'sendrecv' || direction === 'sendonly')) {
+            track = rtpReceiver.track;
+            if (remoteMsid) {
+              if (!streams[remoteMsid.stream]) {
+                streams[remoteMsid.stream] = new window.MediaStream();
+              }
+              addTrackToStreamAndFireEvent(track, streams[remoteMsid.stream]);
+              receiverList.push([track, rtpReceiver, streams[remoteMsid.stream]]);
+            } else {
+              if (!streams.default) {
+                streams.default = new window.MediaStream();
+              }
+              addTrackToStreamAndFireEvent(track, streams.default);
+              receiverList.push([track, rtpReceiver, streams.default]);
+            }
+          } else {
+            // FIXME: actually the receiver should be created later.
+            delete transceiver.rtpReceiver;
+          }
+        }
+      });
+
+      if (pc._dtlsRole === undefined) {
+        pc._dtlsRole = description.type === 'offer' ? 'active' : 'passive';
+      }
+
+      pc._remoteDescription = {
+        type: description.type,
+        sdp: description.sdp
+      };
+      if (description.type === 'offer') {
+        pc._updateSignalingState('have-remote-offer');
+      } else {
+        pc._updateSignalingState('stable');
+      }
+      Object.keys(streams).forEach(function (sid) {
+        var stream = streams[sid];
+        if (stream.getTracks().length) {
+          if (pc.remoteStreams.indexOf(stream) === -1) {
+            pc.remoteStreams.push(stream);
+            var event = new Event('addstream');
+            event.stream = stream;
+            window.setTimeout(function () {
+              pc._dispatchEvent('addstream', event);
+            });
+          }
+
+          receiverList.forEach(function (item) {
+            var track = item[0];
+            var receiver = item[1];
+            if (stream.id !== item[2].id) {
+              return;
+            }
+            fireAddTrack(pc, track, receiver, [stream]);
+          });
+        }
+      });
+      receiverList.forEach(function (item) {
+        if (item[2]) {
+          return;
+        }
+        fireAddTrack(pc, item[0], item[1], []);
+      });
+
+      // check whether addIceCandidate({}) was called within four seconds after
+      // setRemoteDescription.
+      window.setTimeout(function () {
+        if (!(pc && pc.transceivers)) {
+          return;
+        }
+        pc.transceivers.forEach(function (transceiver) {
+          if (transceiver.iceTransport &&
+            transceiver.iceTransport.state === 'new' &&
+            transceiver.iceTransport.getRemoteCandidates().length > 0) {
+            console.warn('Timeout for addRemoteCandidate. Consider sending ' +
+              'an end-of-candidates notification');
+            transceiver.iceTransport.addRemoteCandidate({});
+          }
+        });
+      }, 4000);
+
+      return Promise.resolve();
+    };
+
+    RTCPeerConnection.prototype.close = function () {
+      this.transceivers.forEach(function (transceiver) {
+        /* not yet
+	      if (transceiver.iceGatherer) {
+	        transceiver.iceGatherer.close();
+	      }
+	      */
+        if (transceiver.iceTransport) {
+          transceiver.iceTransport.stop();
+        }
+        if (transceiver.dtlsTransport) {
+          transceiver.dtlsTransport.stop();
+        }
+        if (transceiver.rtpSender) {
+          transceiver.rtpSender.stop();
+        }
+        if (transceiver.rtpReceiver) {
+          transceiver.rtpReceiver.stop();
+        }
+      });
+      // FIXME: clean up tracks, local streams, remote streams, etc
+      this._isClosed = true;
+      this._updateSignalingState('closed');
+    };
+
+    // Update the signaling state.
+    RTCPeerConnection.prototype._updateSignalingState = function (newState) {
+      this.signalingState = newState;
+      var event = new Event('signalingstatechange');
+      this._dispatchEvent('signalingstatechange', event);
+    };
+
+    // Determine whether to fire the negotiationneeded event.
+    RTCPeerConnection.prototype._maybeFireNegotiationNeeded = function () {
+      var pc = this;
+      if (this.signalingState !== 'stable' || this.needNegotiation === true) {
+        return;
+      }
+      this.needNegotiation = true;
+      window.setTimeout(function () {
+        if (pc.needNegotiation) {
+          pc.needNegotiation = false;
+          var event = new Event('negotiationneeded');
+          pc._dispatchEvent('negotiationneeded', event);
+        }
+      }, 0);
+    };
+
+    // Update the ice connection state.
+    RTCPeerConnection.prototype._updateIceConnectionState = function () {
+      var newState;
+      var states = {
+        'new': 0,
+        closed: 0,
+        checking: 0,
+        connected: 0,
+        completed: 0,
+        disconnected: 0,
+        failed: 0
+      };
+      this.transceivers.forEach(function (transceiver) {
+        if (transceiver.iceTransport && !transceiver.rejected) {
+          states[transceiver.iceTransport.state]++;
+        }
+      });
+
+      newState = 'new';
+      if (states.failed > 0) {
+        newState = 'failed';
+      } else if (states.checking > 0) {
+        newState = 'checking';
+      } else if (states.disconnected > 0) {
+        newState = 'disconnected';
+      } else if (states.new > 0) {
+        newState = 'new';
+      } else if (states.connected > 0) {
+        newState = 'connected';
+      } else if (states.completed > 0) {
+        newState = 'completed';
+      }
+
+      if (newState !== this.iceConnectionState) {
+        this.iceConnectionState = newState;
+        var event = new Event('iceconnectionstatechange');
+        this._dispatchEvent('iceconnectionstatechange', event);
+      }
+    };
+
+    // Update the connection state.
+    RTCPeerConnection.prototype._updateConnectionState = function () {
+      var newState;
+      var states = {
+        'new': 0,
+        closed: 0,
+        connecting: 0,
+        connected: 0,
+        completed: 0,
+        disconnected: 0,
+        failed: 0
+      };
+      this.transceivers.forEach(function (transceiver) {
+        if (transceiver.iceTransport && transceiver.dtlsTransport &&
+          !transceiver.rejected) {
+          states[transceiver.iceTransport.state]++;
+          states[transceiver.dtlsTransport.state]++;
+        }
+      });
+      // ICETransport.completed and connected are the same for this purpose.
+      states.connected += states.completed;
+
+      newState = 'new';
+      if (states.failed > 0) {
+        newState = 'failed';
+      } else if (states.connecting > 0) {
+        newState = 'connecting';
+      } else if (states.disconnected > 0) {
+        newState = 'disconnected';
+      } else if (states.new > 0) {
+        newState = 'new';
+      } else if (states.connected > 0) {
+        newState = 'connected';
+      }
+
+      if (newState !== this.connectionState) {
+        this.connectionState = newState;
+        var event = new Event('connectionstatechange');
+        this._dispatchEvent('connectionstatechange', event);
+      }
+    };
+
+    RTCPeerConnection.prototype.createOffer = function () {
+      var pc = this;
+
+      if (pc._isClosed) {
+        return Promise.reject(makeError('InvalidStateError',
+          'Can not call createOffer after close'));
+      }
+
+      var numAudioTracks = pc.transceivers.filter(function (t) {
+        return t.kind === 'audio';
+      }).length;
+      var numVideoTracks = pc.transceivers.filter(function (t) {
+        return t.kind === 'video';
+      }).length;
+
+      // Determine number of audio and video tracks we need to send/recv.
+      var offerOptions = arguments[0];
+      if (offerOptions) {
+        // Reject Chrome legacy constraints.
+        if (offerOptions.mandatory || offerOptions.optional) {
+          throw new TypeError(
+            'Legacy mandatory/optional constraints not supported.');
+        }
+        if (offerOptions.offerToReceiveAudio !== undefined) {
+          if (offerOptions.offerToReceiveAudio === true) {
+            numAudioTracks = 1;
+          } else if (offerOptions.offerToReceiveAudio === false) {
+            numAudioTracks = 0;
+          } else {
+            numAudioTracks = offerOptions.offerToReceiveAudio;
+          }
+        }
+        if (offerOptions.offerToReceiveVideo !== undefined) {
+          if (offerOptions.offerToReceiveVideo === true) {
+            numVideoTracks = 1;
+          } else if (offerOptions.offerToReceiveVideo === false) {
+            numVideoTracks = 0;
+          } else {
+            numVideoTracks = offerOptions.offerToReceiveVideo;
+          }
+        }
+      }
+
+      pc.transceivers.forEach(function (transceiver) {
+        if (transceiver.kind === 'audio') {
+          numAudioTracks--;
+          if (numAudioTracks < 0) {
+            transceiver.wantReceive = false;
+          }
+        } else if (transceiver.kind === 'video') {
+          numVideoTracks--;
+          if (numVideoTracks < 0) {
+            transceiver.wantReceive = false;
+          }
+        }
+      });
+
+      // Create M-lines for recvonly streams.
+      while (numAudioTracks > 0 || numVideoTracks > 0) {
+        if (numAudioTracks > 0) {
+          pc._createTransceiver('audio');
+          numAudioTracks--;
+        }
+        if (numVideoTracks > 0) {
+          pc._createTransceiver('video');
+          numVideoTracks--;
+        }
+      }
+
+      var sdp$1 = sdp.writeSessionBoilerplate(pc._sdpSessionId,
+        pc._sdpSessionVersion++);
+      pc.transceivers.forEach(function (transceiver, sdpMLineIndex) {
+        // For each track, create an ice gatherer, ice transport,
+        // dtls transport, potentially rtpsender and rtpreceiver.
+        var track = transceiver.track;
+        var kind = transceiver.kind;
+        var mid = transceiver.mid || sdp.generateIdentifier();
+        transceiver.mid = mid;
+
+        if (!transceiver.iceGatherer) {
+          transceiver.iceGatherer = pc._createIceGatherer(sdpMLineIndex,
+            pc.usingBundle);
+        }
+
+        var localCapabilities = window.RTCRtpSender.getCapabilities(kind);
+        // filter RTX until additional stuff needed for RTX is implemented
+        // in adapter.js
+        if (edgeVersion < 15019) {
+          localCapabilities.codecs = localCapabilities.codecs.filter(
+            function (codec) {
+              return codec.name !== 'rtx';
+            });
+        }
+        localCapabilities.codecs.forEach(function (codec) {
+          // work around https://bugs.chromium.org/p/webrtc/issues/detail?id=6552
+          // by adding level-asymmetry-allowed=1
+          if (codec.name === 'H264' &&
+            codec.parameters['level-asymmetry-allowed'] === undefined) {
+            codec.parameters['level-asymmetry-allowed'] = '1';
+          }
+
+          // for subsequent offers, we might have to re-use the payload
+          // type of the last offer.
+          if (transceiver.remoteCapabilities &&
+            transceiver.remoteCapabilities.codecs) {
+            transceiver.remoteCapabilities.codecs.forEach(function (remoteCodec) {
+              if (codec.name.toLowerCase() === remoteCodec.name.toLowerCase() &&
+                codec.clockRate === remoteCodec.clockRate) {
+                codec.preferredPayloadType = remoteCodec.payloadType;
+              }
+            });
+          }
+        });
+        localCapabilities.headerExtensions.forEach(function (hdrExt) {
+          var remoteExtensions = transceiver.remoteCapabilities &&
+            transceiver.remoteCapabilities.headerExtensions || [];
+          remoteExtensions.forEach(function (rHdrExt) {
+            if (hdrExt.uri === rHdrExt.uri) {
+              hdrExt.id = rHdrExt.id;
+            }
+          });
+        });
+
+        // generate an ssrc now, to be used later in rtpSender.send
+        var sendEncodingParameters = transceiver.sendEncodingParameters || [{
+          ssrc: (2 * sdpMLineIndex + 1) * 1001
+        }];
+        if (track) {
+          // add RTX
+          if (edgeVersion >= 15019 && kind === 'video' &&
+            !sendEncodingParameters[0].rtx) {
+            sendEncodingParameters[0].rtx = {
+              ssrc: sendEncodingParameters[0].ssrc + 1
+            };
+          }
+        }
+
+        if (transceiver.wantReceive) {
+          transceiver.rtpReceiver = new window.RTCRtpReceiver(
+            transceiver.dtlsTransport, kind);
+        }
+
+        transceiver.localCapabilities = localCapabilities;
+        transceiver.sendEncodingParameters = sendEncodingParameters;
+      });
+
+      // always offer BUNDLE and dispose on return if not supported.
+      if (pc._config.bundlePolicy !== 'max-compat') {
+        sdp$1 += 'a=group:BUNDLE ' + pc.transceivers.map(function (t) {
+          return t.mid;
+        }).join(' ') + '\r\n';
+      }
+      sdp$1 += 'a=ice-options:trickle\r\n';
+
+      pc.transceivers.forEach(function (transceiver, sdpMLineIndex) {
+        sdp$1 += writeMediaSection(transceiver, transceiver.localCapabilities,
+          'offer', transceiver.stream, pc._dtlsRole);
+        sdp$1 += 'a=rtcp-rsize\r\n';
+
+        if (transceiver.iceGatherer && pc.iceGatheringState !== 'new' &&
+          (sdpMLineIndex === 0 || !pc.usingBundle)) {
+          transceiver.iceGatherer.getLocalCandidates().forEach(function (cand) {
+            cand.component = 1;
+            sdp$1 += 'a=' + sdp.writeCandidate(cand) + '\r\n';
+          });
+
+          if (transceiver.iceGatherer.state === 'completed') {
+            sdp$1 += 'a=end-of-candidates\r\n';
+          }
+        }
+      });
+
+      var desc = new window.RTCSessionDescription({
+        type: 'offer',
+        sdp: sdp$1
+      });
+      return Promise.resolve(desc);
+    };
+
+    RTCPeerConnection.prototype.createAnswer = function () {
+      var pc = this;
+
+      if (pc._isClosed) {
+        return Promise.reject(makeError('InvalidStateError',
+          'Can not call createAnswer after close'));
+      }
+
+      if (!(pc.signalingState === 'have-remote-offer' ||
+        pc.signalingState === 'have-local-pranswer')) {
+        return Promise.reject(makeError('InvalidStateError',
+          'Can not call createAnswer in signalingState ' + pc.signalingState));
+      }
+
+      var sdp$1 = sdp.writeSessionBoilerplate(pc._sdpSessionId,
+        pc._sdpSessionVersion++);
+      if (pc.usingBundle) {
+        sdp$1 += 'a=group:BUNDLE ' + pc.transceivers.map(function (t) {
+          return t.mid;
+        }).join(' ') + '\r\n';
+      }
+      sdp$1 += 'a=ice-options:trickle\r\n';
+
+      var mediaSectionsInOffer = sdp.getMediaSections(
+        pc._remoteDescription.sdp).length;
+      pc.transceivers.forEach(function (transceiver, sdpMLineIndex) {
+        if (sdpMLineIndex + 1 > mediaSectionsInOffer) {
+          return;
+        }
+        if (transceiver.rejected) {
+          if (transceiver.kind === 'application') {
+            if (transceiver.protocol === 'DTLS/SCTP') { // legacy fmt
+              sdp$1 += 'm=application 0 DTLS/SCTP 5000\r\n';
+            } else {
+              sdp$1 += 'm=application 0 ' + transceiver.protocol +
+                ' webrtc-datachannel\r\n';
+            }
+          } else if (transceiver.kind === 'audio') {
+            sdp$1 += 'm=audio 0 UDP/TLS/RTP/SAVPF 0\r\n' +
+              'a=rtpmap:0 PCMU/8000\r\n';
+          } else if (transceiver.kind === 'video') {
+            sdp$1 += 'm=video 0 UDP/TLS/RTP/SAVPF 120\r\n' +
+              'a=rtpmap:120 VP8/90000\r\n';
+          }
+          sdp$1 += 'c=IN IP4 0.0.0.0\r\n' +
+            'a=inactive\r\n' +
+            'a=mid:' + transceiver.mid + '\r\n';
+          return;
+        }
+
+        // FIXME: look at direction.
+        if (transceiver.stream) {
+          var localTrack;
+          if (transceiver.kind === 'audio') {
+            localTrack = transceiver.stream.getAudioTracks()[0];
+          } else if (transceiver.kind === 'video') {
+            localTrack = transceiver.stream.getVideoTracks()[0];
+          }
+          if (localTrack) {
+            // add RTX
+            if (edgeVersion >= 15019 && transceiver.kind === 'video' &&
+              !transceiver.sendEncodingParameters[0].rtx) {
+              transceiver.sendEncodingParameters[0].rtx = {
+                ssrc: transceiver.sendEncodingParameters[0].ssrc + 1
+              };
+            }
+          }
+        }
+
+        // Calculate intersection of capabilities.
+        var commonCapabilities = getCommonCapabilities(
+          transceiver.localCapabilities,
+          transceiver.remoteCapabilities);
+
+        var hasRtx = commonCapabilities.codecs.filter(function (c) {
+          return c.name.toLowerCase() === 'rtx';
+        }).length;
+        if (!hasRtx && transceiver.sendEncodingParameters[0].rtx) {
+          delete transceiver.sendEncodingParameters[0].rtx;
+        }
+
+        sdp$1 += writeMediaSection(transceiver, commonCapabilities,
+          'answer', transceiver.stream, pc._dtlsRole);
+        if (transceiver.rtcpParameters &&
+          transceiver.rtcpParameters.reducedSize) {
+          sdp$1 += 'a=rtcp-rsize\r\n';
+        }
+      });
+
+      var desc = new window.RTCSessionDescription({
+        type: 'answer',
+        sdp: sdp$1
+      });
+      return Promise.resolve(desc);
+    };
+
+    RTCPeerConnection.prototype.addIceCandidate = function (candidate) {
+      var pc = this;
+      var sections;
+      if (candidate && !(candidate.sdpMLineIndex !== undefined ||
+        candidate.sdpMid)) {
+        return Promise.reject(new TypeError('sdpMLineIndex or sdpMid required'));
+      }
+
+      // TODO: needs to go into ops queue.
+      return new Promise(function (resolve, reject) {
+        if (!pc._remoteDescription) {
+          return reject(makeError('InvalidStateError',
+            'Can not add ICE candidate without a remote description'));
+        } else if (!candidate || candidate.candidate === '') {
+          for (var j = 0; j < pc.transceivers.length; j++) {
+            if (pc.transceivers[j].rejected) {
+              continue;
+            }
+            pc.transceivers[j].iceTransport.addRemoteCandidate({});
+            sections = sdp.getMediaSections(pc._remoteDescription.sdp);
+            sections[j] += 'a=end-of-candidates\r\n';
+            pc._remoteDescription.sdp =
+              sdp.getDescription(pc._remoteDescription.sdp) +
+              sections.join('');
+            if (pc.usingBundle) {
+              break;
+            }
+          }
+        } else {
+          var sdpMLineIndex = candidate.sdpMLineIndex;
+          if (candidate.sdpMid) {
+            for (var i = 0; i < pc.transceivers.length; i++) {
+              if (pc.transceivers[i].mid === candidate.sdpMid) {
+                sdpMLineIndex = i;
+                break;
+              }
+            }
+          }
+          var transceiver = pc.transceivers[sdpMLineIndex];
+          if (transceiver) {
+            if (transceiver.rejected) {
+              return resolve();
+            }
+            var cand = Object.keys(candidate.candidate).length > 0 ?
+              sdp.parseCandidate(candidate.candidate) : {};
+            // Ignore Chrome's invalid candidates since Edge does not like them.
+            if (cand.protocol === 'tcp' && (cand.port === 0 || cand.port === 9)) {
+              return resolve();
+            }
+            // Ignore RTCP candidates, we assume RTCP-MUX.
+            if (cand.component && cand.component !== 1) {
+              return resolve();
+            }
+            // when using bundle, avoid adding candidates to the wrong
+            // ice transport. And avoid adding candidates added in the SDP.
+            if (sdpMLineIndex === 0 || (sdpMLineIndex > 0 &&
+              transceiver.iceTransport !== pc.transceivers[0].iceTransport)) {
+              if (!maybeAddCandidate(transceiver.iceTransport, cand)) {
+                return reject(makeError('OperationError',
+                  'Can not add ICE candidate'));
+              }
+            }
+
+            // update the remoteDescription.
+            var candidateString = candidate.candidate.trim();
+            if (candidateString.indexOf('a=') === 0) {
+              candidateString = candidateString.substr(2);
+            }
+            sections = sdp.getMediaSections(pc._remoteDescription.sdp);
+            sections[sdpMLineIndex] += 'a=' +
+              (cand.type ? candidateString : 'end-of-candidates')
+              + '\r\n';
+            pc._remoteDescription.sdp =
+              sdp.getDescription(pc._remoteDescription.sdp) +
+              sections.join('');
+          } else {
+            return reject(makeError('OperationError',
+              'Can not add ICE candidate'));
+          }
+        }
+        resolve();
+      });
+    };
+
+    RTCPeerConnection.prototype.getStats = function (selector) {
+      if (selector && selector instanceof window.MediaStreamTrack) {
+        var senderOrReceiver = null;
+        this.transceivers.forEach(function (transceiver) {
+          if (transceiver.rtpSender &&
+            transceiver.rtpSender.track === selector) {
+            senderOrReceiver = transceiver.rtpSender;
+          } else if (transceiver.rtpReceiver &&
+            transceiver.rtpReceiver.track === selector) {
+            senderOrReceiver = transceiver.rtpReceiver;
+          }
+        });
+        if (!senderOrReceiver) {
+          throw makeError('InvalidAccessError', 'Invalid selector.');
+        }
+        return senderOrReceiver.getStats();
+      }
+
+      var promises = [];
+      this.transceivers.forEach(function (transceiver) {
+        ['rtpSender', 'rtpReceiver', 'iceGatherer', 'iceTransport',
+          'dtlsTransport'].forEach(function (method) {
+          if (transceiver[method]) {
+            promises.push(transceiver[method].getStats());
+          }
+        });
+      });
+      return Promise.all(promises).then(function (allStats) {
+        var results = new Map();
+        allStats.forEach(function (stats) {
+          stats.forEach(function (stat) {
+            results.set(stat.id, stat);
+          });
+        });
+        return results;
+      });
+    };
+
+    // fix low-level stat names and return Map instead of object.
+    var ortcObjects = ['RTCRtpSender', 'RTCRtpReceiver', 'RTCIceGatherer',
+      'RTCIceTransport', 'RTCDtlsTransport'];
+    ortcObjects.forEach(function (ortcObjectName) {
+      var obj = window[ortcObjectName];
+      if (obj && obj.prototype && obj.prototype.getStats) {
+        var nativeGetstats = obj.prototype.getStats;
+        obj.prototype.getStats = function () {
+          return nativeGetstats.apply(this)
+            .then(function (nativeStats) {
+              var mapStats = new Map();
+              Object.keys(nativeStats).forEach(function (id) {
+                nativeStats[id].type = fixStatsType(nativeStats[id]);
+                mapStats.set(id, nativeStats[id]);
+              });
+              return mapStats;
+            });
+        };
+      }
+    });
+
+    // legacy callback shims. Should be moved to adapter.js some days.
+    var methods = ['createOffer', 'createAnswer'];
+    methods.forEach(function (method) {
+      var nativeMethod = RTCPeerConnection.prototype[method];
+      RTCPeerConnection.prototype[method] = function () {
+        var args = arguments;
+        if (typeof args[0] === 'function' ||
+          typeof args[1] === 'function') { // legacy
+          return nativeMethod.apply(this, [arguments[2]])
+            .then(function (description) {
+              if (typeof args[0] === 'function') {
+                args[0].apply(null, [description]);
+              }
+            }, function (error) {
+              if (typeof args[1] === 'function') {
+                args[1].apply(null, [error]);
+              }
+            });
+        }
+        return nativeMethod.apply(this, arguments);
+      };
+    });
+
+    methods = ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate'];
+    methods.forEach(function (method) {
+      var nativeMethod = RTCPeerConnection.prototype[method];
+      RTCPeerConnection.prototype[method] = function () {
+        var args = arguments;
+        if (typeof args[1] === 'function' ||
+          typeof args[2] === 'function') { // legacy
+          return nativeMethod.apply(this, arguments)
+            .then(function () {
+              if (typeof args[1] === 'function') {
+                args[1].apply(null);
+              }
+            }, function (error) {
+              if (typeof args[2] === 'function') {
+                args[2].apply(null, [error]);
+              }
+            });
+        }
+        return nativeMethod.apply(this, arguments);
+      };
+    });
+
+    // getStats is special. It doesn't have a spec legacy method yet we support
+    // getStats(something, cb) without error callbacks.
+    ['getStats'].forEach(function (method) {
+      var nativeMethod = RTCPeerConnection.prototype[method];
+      RTCPeerConnection.prototype[method] = function () {
+        var args = arguments;
+        if (typeof args[1] === 'function') {
+          return nativeMethod.apply(this, arguments)
+            .then(function () {
+              if (typeof args[1] === 'function') {
+                args[1].apply(null);
+              }
+            });
+        }
+        return nativeMethod.apply(this, arguments);
+      };
+    });
+
+    return RTCPeerConnection;
+  };
+
+  /*
+	 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  function shimGetUserMedia$2(window) {
+    const navigator = window && window.navigator;
+
+    const shimError_ = function (e) {
+      return {
+        name: {PermissionDeniedError: 'NotAllowedError'}[e.name] || e.name,
+        message: e.message,
+        constraint: e.constraint,
+        toString() {
+          return this.name;
+        }
+      };
+    };
+
+    // getUserMedia error shim.
+    const origGetUserMedia = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
+    navigator.mediaDevices.getUserMedia = function (c) {
+      return origGetUserMedia(c).catch(e => Promise.reject(shimError_(e)));
+    };
+  }
+
+  /*
+	 *  Copyright (c) 2018 The adapter.js project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  function shimGetDisplayMedia$1(window) {
+    if (!('getDisplayMedia' in window.navigator)) {
+      return;
+    }
+    if (!(window.navigator.mediaDevices)) {
+      return;
+    }
+    if (window.navigator.mediaDevices &&
+      'getDisplayMedia' in window.navigator.mediaDevices) {
+      return;
+    }
+    window.navigator.mediaDevices.getDisplayMedia =
+      window.navigator.getDisplayMedia.bind(window.navigator);
+  }
+
+  /*
+	 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  function shimPeerConnection$1(window, browserDetails) {
+    if (window.RTCIceGatherer) {
+      if (!window.RTCIceCandidate) {
+        window.RTCIceCandidate = function RTCIceCandidate(args) {
+          return args;
+        };
+      }
+      if (!window.RTCSessionDescription) {
+        window.RTCSessionDescription = function RTCSessionDescription(args) {
+          return args;
+        };
+      }
+      // this adds an additional event listener to MediaStrackTrack that signals
+      // when a tracks enabled property was changed. Workaround for a bug in
+      // addStream, see below. No longer required in 15025+
+      if (browserDetails.version < 15025) {
+        const origMSTEnabled = Object.getOwnPropertyDescriptor(
+          window.MediaStreamTrack.prototype, 'enabled');
+        Object.defineProperty(window.MediaStreamTrack.prototype, 'enabled', {
+          set(value) {
+            origMSTEnabled.set.call(this, value);
+            const ev = new Event('enabled');
+            ev.enabled = value;
+            this.dispatchEvent(ev);
+          }
+        });
+      }
+    }
+
+    // ORTC defines the DTMF sender a bit different.
+    // https://github.com/w3c/ortc/issues/714
+    if (window.RTCRtpSender && !('dtmf' in window.RTCRtpSender.prototype)) {
+      Object.defineProperty(window.RTCRtpSender.prototype, 'dtmf', {
+        get() {
+          if (this._dtmf === undefined) {
+            if (this.track.kind === 'audio') {
+              this._dtmf = new window.RTCDtmfSender(this);
+            } else if (this.track.kind === 'video') {
+              this._dtmf = null;
+            }
+          }
+          return this._dtmf;
+        }
+      });
+    }
+    // Edge currently only implements the RTCDtmfSender, not the
+    // RTCDTMFSender alias. See http://draft.ortc.org/#rtcdtmfsender2*
+    if (window.RTCDtmfSender && !window.RTCDTMFSender) {
+      window.RTCDTMFSender = window.RTCDtmfSender;
+    }
+
+    const RTCPeerConnectionShim = rtcpeerconnection(window,
+      browserDetails.version);
+    window.RTCPeerConnection = function RTCPeerConnection(config) {
+      if (config && config.iceServers) {
+        config.iceServers = filterIceServers$1(config.iceServers,
+          browserDetails.version);
+        log$1('ICE servers after filtering:', config.iceServers);
+      }
+      return new RTCPeerConnectionShim(config);
+    };
+    window.RTCPeerConnection.prototype = RTCPeerConnectionShim.prototype;
+  }
+
+  function shimReplaceTrack(window) {
+    // ORTC has replaceTrack -- https://github.com/w3c/ortc/issues/614
+    if (window.RTCRtpSender &&
+      !('replaceTrack' in window.RTCRtpSender.prototype)) {
+      window.RTCRtpSender.prototype.replaceTrack =
+        window.RTCRtpSender.prototype.setTrack;
+    }
+  }
+
+  var edgeShim = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    shimPeerConnection: shimPeerConnection$1,
+    shimReplaceTrack: shimReplaceTrack,
+    shimGetUserMedia: shimGetUserMedia$2,
+    shimGetDisplayMedia: shimGetDisplayMedia$1
+  });
+
+  /*
+	 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  function shimGetUserMedia$1(window, browserDetails) {
+    const navigator = window && window.navigator;
+    const MediaStreamTrack = window && window.MediaStreamTrack;
+
+    navigator.getUserMedia = function (constraints, onSuccess, onError) {
+      // Replace Firefox 44+'s deprecation warning with unprefixed version.
+      deprecated('navigator.getUserMedia',
+        'navigator.mediaDevices.getUserMedia');
+      navigator.mediaDevices.getUserMedia(constraints).then(onSuccess, onError);
+    };
+
+    if (!(browserDetails.version > 55 &&
+      'autoGainControl' in navigator.mediaDevices.getSupportedConstraints())) {
+      const remap = function (obj, a, b) {
+        if (a in obj && !(b in obj)) {
+          obj[b] = obj[a];
+          delete obj[a];
+        }
+      };
+
+      const nativeGetUserMedia = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
+      navigator.mediaDevices.getUserMedia = function (c) {
+        if (typeof c === 'object' && typeof c.audio === 'object') {
+          c = JSON.parse(JSON.stringify(c));
+          remap(c.audio, 'autoGainControl', 'mozAutoGainControl');
+          remap(c.audio, 'noiseSuppression', 'mozNoiseSuppression');
+        }
+        return nativeGetUserMedia(c);
+      };
+
+      if (MediaStreamTrack && MediaStreamTrack.prototype.getSettings) {
+        const nativeGetSettings = MediaStreamTrack.prototype.getSettings;
+        MediaStreamTrack.prototype.getSettings = function () {
+          const obj = nativeGetSettings.apply(this, arguments);
+          remap(obj, 'mozAutoGainControl', 'autoGainControl');
+          remap(obj, 'mozNoiseSuppression', 'noiseSuppression');
+          return obj;
+        };
+      }
+
+      if (MediaStreamTrack && MediaStreamTrack.prototype.applyConstraints) {
+        const nativeApplyConstraints =
+          MediaStreamTrack.prototype.applyConstraints;
+        MediaStreamTrack.prototype.applyConstraints = function (c) {
+          if (this.kind === 'audio' && typeof c === 'object') {
+            c = JSON.parse(JSON.stringify(c));
+            remap(c, 'autoGainControl', 'mozAutoGainControl');
+            remap(c, 'noiseSuppression', 'mozNoiseSuppression');
+          }
+          return nativeApplyConstraints.apply(this, [c]);
+        };
+      }
+    }
+  }
+
+  /*
+	 *  Copyright (c) 2018 The adapter.js project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  function shimGetDisplayMedia(window, preferredMediaSource) {
+    if (window.navigator.mediaDevices &&
+      'getDisplayMedia' in window.navigator.mediaDevices) {
+      return;
+    }
+    if (!(window.navigator.mediaDevices)) {
+      return;
+    }
+    window.navigator.mediaDevices.getDisplayMedia =
+      function getDisplayMedia(constraints) {
+        if (!(constraints && constraints.video)) {
+          const err = new DOMException('getDisplayMedia without video ' +
+            'constraints is undefined');
+          err.name = 'NotFoundError';
+          // from https://heycam.github.io/webidl/#idl-DOMException-error-names
+          err.code = 8;
+          return Promise.reject(err);
+        }
+        if (constraints.video === true) {
+          constraints.video = {mediaSource: preferredMediaSource};
+        } else {
+          constraints.video.mediaSource = preferredMediaSource;
+        }
+        return window.navigator.mediaDevices.getUserMedia(constraints);
+      };
+  }
+
+  /*
+	 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  function shimOnTrack(window) {
+    if (typeof window === 'object' && window.RTCTrackEvent &&
+      ('receiver' in window.RTCTrackEvent.prototype) &&
+      !('transceiver' in window.RTCTrackEvent.prototype)) {
+      Object.defineProperty(window.RTCTrackEvent.prototype, 'transceiver', {
+        get() {
+          return {receiver: this.receiver};
+        }
+      });
+    }
+  }
+
+  function shimPeerConnection(window, browserDetails) {
+    if (typeof window !== 'object' ||
+      !(window.RTCPeerConnection || window.mozRTCPeerConnection)) {
+      return; // probably media.peerconnection.enabled=false in about:config
+    }
+    if (!window.RTCPeerConnection && window.mozRTCPeerConnection) {
+      // very basic support for old versions.
+      window.RTCPeerConnection = window.mozRTCPeerConnection;
+    }
+
+    if (browserDetails.version < 53) {
+      // shim away need for obsolete RTCIceCandidate/RTCSessionDescription.
+      ['setLocalDescription', 'setRemoteDescription', 'addIceCandidate']
+        .forEach(function (method) {
+          const nativeMethod = window.RTCPeerConnection.prototype[method];
+          const methodObj = {
+            [method]() {
+              arguments[0] = new ((method === 'addIceCandidate') ?
+                window.RTCIceCandidate :
+                window.RTCSessionDescription)(arguments[0]);
+              return nativeMethod.apply(this, arguments);
+            }
+          };
+          window.RTCPeerConnection.prototype[method] = methodObj[method];
+        });
+    }
+
+    const modernStatsTypes = {
+      inboundrtp: 'inbound-rtp',
+      outboundrtp: 'outbound-rtp',
+      candidatepair: 'candidate-pair',
+      localcandidate: 'local-candidate',
+      remotecandidate: 'remote-candidate'
+    };
+
+    const nativeGetStats = window.RTCPeerConnection.prototype.getStats;
+    window.RTCPeerConnection.prototype.getStats = function getStats() {
+      const [selector, onSucc, onErr] = arguments;
+      return nativeGetStats.apply(this, [selector || null])
+        .then(stats => {
+          if (browserDetails.version < 53 && !onSucc) {
+            // Shim only promise getStats with spec-hyphens in type names
+            // Leave callback version alone; misc old uses of forEach before Map
+            try {
+              stats.forEach(stat => {
+                stat.type = modernStatsTypes[stat.type] || stat.type;
+              });
+            } catch (e) {
+              if (e.name !== 'TypeError') {
+                throw e;
+              }
+              // Avoid TypeError: "type" is read-only, in old versions. 34-43ish
+              stats.forEach((stat, i) => {
+                stats.set(i, Object.assign({}, stat, {
+                  type: modernStatsTypes[stat.type] || stat.type
+                }));
+              });
+            }
+          }
+          return stats;
+        })
+        .then(onSucc, onErr);
+    };
+  }
+
+  function shimSenderGetStats(window) {
+    if (!(typeof window === 'object' && window.RTCPeerConnection &&
+      window.RTCRtpSender)) {
+      return;
+    }
+    if (window.RTCRtpSender && 'getStats' in window.RTCRtpSender.prototype) {
+      return;
+    }
+    const origGetSenders = window.RTCPeerConnection.prototype.getSenders;
+    if (origGetSenders) {
+      window.RTCPeerConnection.prototype.getSenders = function getSenders() {
+        const senders = origGetSenders.apply(this, []);
+        senders.forEach(sender => sender._pc = this);
+        return senders;
+      };
+    }
+
+    const origAddTrack = window.RTCPeerConnection.prototype.addTrack;
+    if (origAddTrack) {
+      window.RTCPeerConnection.prototype.addTrack = function addTrack() {
+        const sender = origAddTrack.apply(this, arguments);
+        sender._pc = this;
+        return sender;
+      };
+    }
+    window.RTCRtpSender.prototype.getStats = function getStats() {
+      return this.track ? this._pc.getStats(this.track) :
+        Promise.resolve(new Map());
+    };
+  }
+
+  function shimReceiverGetStats(window) {
+    if (!(typeof window === 'object' && window.RTCPeerConnection &&
+      window.RTCRtpSender)) {
+      return;
+    }
+    if (window.RTCRtpSender && 'getStats' in window.RTCRtpReceiver.prototype) {
+      return;
+    }
+    const origGetReceivers = window.RTCPeerConnection.prototype.getReceivers;
+    if (origGetReceivers) {
+      window.RTCPeerConnection.prototype.getReceivers = function getReceivers() {
+        const receivers = origGetReceivers.apply(this, []);
+        receivers.forEach(receiver => receiver._pc = this);
+        return receivers;
+      };
+    }
+    wrapPeerConnectionEvent(window, 'track', e => {
+      e.receiver._pc = e.srcElement;
+      return e;
+    });
+    window.RTCRtpReceiver.prototype.getStats = function getStats() {
+      return this._pc.getStats(this.track);
+    };
+  }
+
+  function shimRemoveStream(window) {
+    if (!window.RTCPeerConnection ||
+      'removeStream' in window.RTCPeerConnection.prototype) {
+      return;
+    }
+    window.RTCPeerConnection.prototype.removeStream =
+      function removeStream(stream) {
+        deprecated('removeStream', 'removeTrack');
+        this.getSenders().forEach(sender => {
+          if (sender.track && stream.getTracks().includes(sender.track)) {
+            this.removeTrack(sender);
+          }
+        });
+      };
+  }
+
+  function shimRTCDataChannel(window) {
+    // rename DataChannel to RTCDataChannel (native fix in FF60):
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1173851
+    if (window.DataChannel && !window.RTCDataChannel) {
+      window.RTCDataChannel = window.DataChannel;
+    }
+  }
+
+  function shimAddTransceiver(window) {
+    // https://github.com/webrtcHacks/adapter/issues/998#issuecomment-516921647
+    // Firefox ignores the init sendEncodings options passed to addTransceiver
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1396918
+    if (!(typeof window === 'object' && window.RTCPeerConnection)) {
+      return;
+    }
+    const origAddTransceiver = window.RTCPeerConnection.prototype.addTransceiver;
+    if (origAddTransceiver) {
+      window.RTCPeerConnection.prototype.addTransceiver =
+        function addTransceiver() {
+          this.setParametersPromises = [];
+          const initParameters = arguments[1];
+          const shouldPerformCheck = initParameters &&
+            'sendEncodings' in initParameters;
+          if (shouldPerformCheck) {
+            // If sendEncodings params are provided, validate grammar
+            initParameters.sendEncodings.forEach((encodingParam) => {
+              if ('rid' in encodingParam) {
+                const ridRegex = /^[a-z0-9]{0,16}$/i;
+                if (!ridRegex.test(encodingParam.rid)) {
+                  throw new TypeError('Invalid RID value provided.');
+                }
+              }
+              if ('scaleResolutionDownBy' in encodingParam) {
+                if (!(parseFloat(encodingParam.scaleResolutionDownBy) >= 1.0)) {
+                  throw new RangeError('scale_resolution_down_by must be >= 1.0');
+                }
+              }
+              if ('maxFramerate' in encodingParam) {
+                if (!(parseFloat(encodingParam.maxFramerate) >= 0)) {
+                  throw new RangeError('max_framerate must be >= 0.0');
+                }
+              }
+            });
+          }
+          const transceiver = origAddTransceiver.apply(this, arguments);
+          if (shouldPerformCheck) {
+            // Check if the init options were applied. If not we do this in an
+            // asynchronous way and save the promise reference in a global object.
+            // This is an ugly hack, but at the same time is way more robust than
+            // checking the sender parameters before and after the createOffer
+            // Also note that after the createoffer we are not 100% sure that
+            // the params were asynchronously applied so we might miss the
+            // opportunity to recreate offer.
+            const {sender} = transceiver;
+            const params = sender.getParameters();
+            if (!('encodings' in params) ||
+              // Avoid being fooled by patched getParameters() below.
+              (params.encodings.length === 1 &&
+                Object.keys(params.encodings[0]).length === 0)) {
+              params.encodings = initParameters.sendEncodings;
+              sender.sendEncodings = initParameters.sendEncodings;
+              this.setParametersPromises.push(sender.setParameters(params)
+                .then(() => {
+                  delete sender.sendEncodings;
+                }).catch(() => {
+                  delete sender.sendEncodings;
+                })
+              );
+            }
+          }
+          return transceiver;
+        };
+    }
+  }
+
+  function shimGetParameters(window) {
+    if (!(typeof window === 'object' && window.RTCRtpSender)) {
+      return;
+    }
+    const origGetParameters = window.RTCRtpSender.prototype.getParameters;
+    if (origGetParameters) {
+      window.RTCRtpSender.prototype.getParameters =
+        function getParameters() {
+          const params = origGetParameters.apply(this, arguments);
+          if (!('encodings' in params)) {
+            params.encodings = [].concat(this.sendEncodings || [{}]);
+          }
+          return params;
+        };
+    }
+  }
+
+  function shimCreateOffer(window) {
+    // https://github.com/webrtcHacks/adapter/issues/998#issuecomment-516921647
+    // Firefox ignores the init sendEncodings options passed to addTransceiver
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1396918
+    if (!(typeof window === 'object' && window.RTCPeerConnection)) {
+      return;
+    }
+    const origCreateOffer = window.RTCPeerConnection.prototype.createOffer;
+    window.RTCPeerConnection.prototype.createOffer = function createOffer() {
+      if (this.setParametersPromises && this.setParametersPromises.length) {
+        return Promise.all(this.setParametersPromises)
+          .then(() => {
+            return origCreateOffer.apply(this, arguments);
+          })
+          .finally(() => {
+            this.setParametersPromises = [];
+          });
+      }
+      return origCreateOffer.apply(this, arguments);
+    };
+  }
+
+  function shimCreateAnswer(window) {
+    // https://github.com/webrtcHacks/adapter/issues/998#issuecomment-516921647
+    // Firefox ignores the init sendEncodings options passed to addTransceiver
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1396918
+    if (!(typeof window === 'object' && window.RTCPeerConnection)) {
+      return;
+    }
+    const origCreateAnswer = window.RTCPeerConnection.prototype.createAnswer;
+    window.RTCPeerConnection.prototype.createAnswer = function createAnswer() {
+      if (this.setParametersPromises && this.setParametersPromises.length) {
+        return Promise.all(this.setParametersPromises)
+          .then(() => {
+            return origCreateAnswer.apply(this, arguments);
+          })
+          .finally(() => {
+            this.setParametersPromises = [];
+          });
+      }
+      return origCreateAnswer.apply(this, arguments);
+    };
+  }
+
+  var firefoxShim = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    shimOnTrack: shimOnTrack,
+    shimPeerConnection: shimPeerConnection,
+    shimSenderGetStats: shimSenderGetStats,
+    shimReceiverGetStats: shimReceiverGetStats,
+    shimRemoveStream: shimRemoveStream,
+    shimRTCDataChannel: shimRTCDataChannel,
+    shimAddTransceiver: shimAddTransceiver,
+    shimGetParameters: shimGetParameters,
+    shimCreateOffer: shimCreateOffer,
+    shimCreateAnswer: shimCreateAnswer,
+    shimGetUserMedia: shimGetUserMedia$1,
+    shimGetDisplayMedia: shimGetDisplayMedia
+  });
+
+  /*
+	 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  function shimLocalStreamsAPI(window) {
+    if (typeof window !== 'object' || !window.RTCPeerConnection) {
+      return;
+    }
+    if (!('getLocalStreams' in window.RTCPeerConnection.prototype)) {
+      window.RTCPeerConnection.prototype.getLocalStreams =
+        function getLocalStreams() {
+          if (!this._localStreams) {
+            this._localStreams = [];
+          }
+          return this._localStreams;
+        };
+    }
+    if (!('addStream' in window.RTCPeerConnection.prototype)) {
+      const _addTrack = window.RTCPeerConnection.prototype.addTrack;
+      window.RTCPeerConnection.prototype.addStream = function addStream(stream) {
+        if (!this._localStreams) {
+          this._localStreams = [];
+        }
+        if (!this._localStreams.includes(stream)) {
+          this._localStreams.push(stream);
+        }
+        // Try to emulate Chrome's behaviour of adding in audio-video order.
+        // Safari orders by track id.
+        stream.getAudioTracks().forEach(track => _addTrack.call(this, track,
+          stream));
+        stream.getVideoTracks().forEach(track => _addTrack.call(this, track,
+          stream));
+      };
+
+      window.RTCPeerConnection.prototype.addTrack =
+        function addTrack(track, ...streams) {
+          if (streams) {
+            streams.forEach((stream) => {
+              if (!this._localStreams) {
+                this._localStreams = [stream];
+              } else if (!this._localStreams.includes(stream)) {
+                this._localStreams.push(stream);
+              }
+            });
+          }
+          return _addTrack.apply(this, arguments);
+        };
+    }
+    if (!('removeStream' in window.RTCPeerConnection.prototype)) {
+      window.RTCPeerConnection.prototype.removeStream =
+        function removeStream(stream) {
+          if (!this._localStreams) {
+            this._localStreams = [];
+          }
+          const index = this._localStreams.indexOf(stream);
+          if (index === -1) {
+            return;
+          }
+          this._localStreams.splice(index, 1);
+          const tracks = stream.getTracks();
+          this.getSenders().forEach(sender => {
+            if (tracks.includes(sender.track)) {
+              this.removeTrack(sender);
+            }
+          });
+        };
+    }
+  }
+
+  function shimRemoteStreamsAPI(window) {
+    if (typeof window !== 'object' || !window.RTCPeerConnection) {
+      return;
+    }
+    if (!('getRemoteStreams' in window.RTCPeerConnection.prototype)) {
+      window.RTCPeerConnection.prototype.getRemoteStreams =
+        function getRemoteStreams() {
+          return this._remoteStreams ? this._remoteStreams : [];
+        };
+    }
+    if (!('onaddstream' in window.RTCPeerConnection.prototype)) {
+      Object.defineProperty(window.RTCPeerConnection.prototype, 'onaddstream', {
+        get() {
+          return this._onaddstream;
+        },
+        set(f) {
+          if (this._onaddstream) {
+            this.removeEventListener('addstream', this._onaddstream);
+            this.removeEventListener('track', this._onaddstreampoly);
+          }
+          this.addEventListener('addstream', this._onaddstream = f);
+          this.addEventListener('track', this._onaddstreampoly = (e) => {
+            e.streams.forEach(stream => {
+              if (!this._remoteStreams) {
+                this._remoteStreams = [];
+              }
+              if (this._remoteStreams.includes(stream)) {
+                return;
+              }
+              this._remoteStreams.push(stream);
+              const event = new Event('addstream');
+              event.stream = stream;
+              this.dispatchEvent(event);
+            });
+          });
+        }
+      });
+      const origSetRemoteDescription =
+        window.RTCPeerConnection.prototype.setRemoteDescription;
+      window.RTCPeerConnection.prototype.setRemoteDescription =
+        function setRemoteDescription() {
+          const pc = this;
+          if (!this._onaddstreampoly) {
+            this.addEventListener('track', this._onaddstreampoly = function (e) {
+              e.streams.forEach(stream => {
+                if (!pc._remoteStreams) {
+                  pc._remoteStreams = [];
+                }
+                if (pc._remoteStreams.indexOf(stream) >= 0) {
+                  return;
+                }
+                pc._remoteStreams.push(stream);
+                const event = new Event('addstream');
+                event.stream = stream;
+                pc.dispatchEvent(event);
+              });
+            });
+          }
+          return origSetRemoteDescription.apply(pc, arguments);
+        };
+    }
+  }
+
+  function shimCallbacksAPI(window) {
+    if (typeof window !== 'object' || !window.RTCPeerConnection) {
+      return;
+    }
+    const prototype = window.RTCPeerConnection.prototype;
+    const origCreateOffer = prototype.createOffer;
+    const origCreateAnswer = prototype.createAnswer;
+    const setLocalDescription = prototype.setLocalDescription;
+    const setRemoteDescription = prototype.setRemoteDescription;
+    const addIceCandidate = prototype.addIceCandidate;
+
+    prototype.createOffer =
+      function createOffer(successCallback, failureCallback) {
+        const options = (arguments.length >= 2) ? arguments[2] : arguments[0];
+        const promise = origCreateOffer.apply(this, [options]);
+        if (!failureCallback) {
+          return promise;
+        }
+        promise.then(successCallback, failureCallback);
+        return Promise.resolve();
+      };
+
+    prototype.createAnswer =
+      function createAnswer(successCallback, failureCallback) {
+        const options = (arguments.length >= 2) ? arguments[2] : arguments[0];
+        const promise = origCreateAnswer.apply(this, [options]);
+        if (!failureCallback) {
+          return promise;
+        }
+        promise.then(successCallback, failureCallback);
+        return Promise.resolve();
+      };
+
+    let withCallback = function (description, successCallback, failureCallback) {
+      const promise = setLocalDescription.apply(this, [description]);
+      if (!failureCallback) {
+        return promise;
+      }
+      promise.then(successCallback, failureCallback);
+      return Promise.resolve();
+    };
+    prototype.setLocalDescription = withCallback;
+
+    withCallback = function (description, successCallback, failureCallback) {
+      const promise = setRemoteDescription.apply(this, [description]);
+      if (!failureCallback) {
+        return promise;
+      }
+      promise.then(successCallback, failureCallback);
+      return Promise.resolve();
+    };
+    prototype.setRemoteDescription = withCallback;
+
+    withCallback = function (candidate, successCallback, failureCallback) {
+      const promise = addIceCandidate.apply(this, [candidate]);
+      if (!failureCallback) {
+        return promise;
+      }
+      promise.then(successCallback, failureCallback);
+      return Promise.resolve();
+    };
+    prototype.addIceCandidate = withCallback;
+  }
+
+  function shimGetUserMedia(window) {
+    const navigator = window && window.navigator;
+
+    if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
+      // shim not needed in Safari 12.1
+      const mediaDevices = navigator.mediaDevices;
+      const _getUserMedia = mediaDevices.getUserMedia.bind(mediaDevices);
+      navigator.mediaDevices.getUserMedia = (constraints) => {
+        return _getUserMedia(shimConstraints(constraints));
+      };
+    }
+
+    if (!navigator.getUserMedia && navigator.mediaDevices &&
+      navigator.mediaDevices.getUserMedia) {
+      navigator.getUserMedia = function getUserMedia(constraints, cb, errcb) {
+        navigator.mediaDevices.getUserMedia(constraints)
+          .then(cb, errcb);
+      }.bind(navigator);
+    }
+  }
+
+  function shimConstraints(constraints) {
+    if (constraints && constraints.video !== undefined) {
+      return Object.assign({},
+        constraints,
+        {video: compactObject(constraints.video)}
+      );
+    }
+
+    return constraints;
+  }
+
+  function shimRTCIceServerUrls(window) {
+    if (!window.RTCPeerConnection) {
+      return;
+    }
+    // migrate from non-spec RTCIceServer.url to RTCIceServer.urls
+    const OrigPeerConnection = window.RTCPeerConnection;
+    window.RTCPeerConnection =
+      function RTCPeerConnection(pcConfig, pcConstraints) {
+        if (pcConfig && pcConfig.iceServers) {
+          const newIceServers = [];
+          for (let i = 0; i < pcConfig.iceServers.length; i++) {
+            let server = pcConfig.iceServers[i];
+            if (!server.hasOwnProperty('urls') &&
+              server.hasOwnProperty('url')) {
+              deprecated('RTCIceServer.url', 'RTCIceServer.urls');
+              server = JSON.parse(JSON.stringify(server));
+              server.urls = server.url;
+              delete server.url;
+              newIceServers.push(server);
+            } else {
+              newIceServers.push(pcConfig.iceServers[i]);
+            }
+          }
+          pcConfig.iceServers = newIceServers;
+        }
+        return new OrigPeerConnection(pcConfig, pcConstraints);
+      };
+    window.RTCPeerConnection.prototype = OrigPeerConnection.prototype;
+    // wrap static methods. Currently just generateCertificate.
+    if ('generateCertificate' in OrigPeerConnection) {
+      Object.defineProperty(window.RTCPeerConnection, 'generateCertificate', {
+        get() {
+          return OrigPeerConnection.generateCertificate;
+        }
+      });
+    }
+  }
+
+  function shimTrackEventTransceiver(window) {
+    // Add event.transceiver member over deprecated event.receiver
+    if (typeof window === 'object' && window.RTCTrackEvent &&
+      'receiver' in window.RTCTrackEvent.prototype &&
+      !('transceiver' in window.RTCTrackEvent.prototype)) {
+      Object.defineProperty(window.RTCTrackEvent.prototype, 'transceiver', {
+        get() {
+          return {receiver: this.receiver};
+        }
+      });
+    }
+  }
+
+  function shimCreateOfferLegacy(window) {
+    const origCreateOffer = window.RTCPeerConnection.prototype.createOffer;
+    window.RTCPeerConnection.prototype.createOffer =
+      function createOffer(offerOptions) {
+        if (offerOptions) {
+          if (typeof offerOptions.offerToReceiveAudio !== 'undefined') {
+            // support bit values
+            offerOptions.offerToReceiveAudio =
+              !!offerOptions.offerToReceiveAudio;
+          }
+          const audioTransceiver = this.getTransceivers().find(transceiver =>
+            transceiver.receiver.track.kind === 'audio');
+          if (offerOptions.offerToReceiveAudio === false && audioTransceiver) {
+            if (audioTransceiver.direction === 'sendrecv') {
+              if (audioTransceiver.setDirection) {
+                audioTransceiver.setDirection('sendonly');
+              } else {
+                audioTransceiver.direction = 'sendonly';
+              }
+            } else if (audioTransceiver.direction === 'recvonly') {
+              if (audioTransceiver.setDirection) {
+                audioTransceiver.setDirection('inactive');
+              } else {
+                audioTransceiver.direction = 'inactive';
+              }
+            }
+          } else if (offerOptions.offerToReceiveAudio === true &&
+            !audioTransceiver) {
+            this.addTransceiver('audio');
+          }
+
+          if (typeof offerOptions.offerToReceiveVideo !== 'undefined') {
+            // support bit values
+            offerOptions.offerToReceiveVideo =
+              !!offerOptions.offerToReceiveVideo;
+          }
+          const videoTransceiver = this.getTransceivers().find(transceiver =>
+            transceiver.receiver.track.kind === 'video');
+          if (offerOptions.offerToReceiveVideo === false && videoTransceiver) {
+            if (videoTransceiver.direction === 'sendrecv') {
+              if (videoTransceiver.setDirection) {
+                videoTransceiver.setDirection('sendonly');
+              } else {
+                videoTransceiver.direction = 'sendonly';
+              }
+            } else if (videoTransceiver.direction === 'recvonly') {
+              if (videoTransceiver.setDirection) {
+                videoTransceiver.setDirection('inactive');
+              } else {
+                videoTransceiver.direction = 'inactive';
+              }
+            }
+          } else if (offerOptions.offerToReceiveVideo === true &&
+            !videoTransceiver) {
+            this.addTransceiver('video');
+          }
+        }
+        return origCreateOffer.apply(this, arguments);
+      };
+  }
+
+  function shimAudioContext(window) {
+    if (typeof window !== 'object' || window.AudioContext) {
+      return;
+    }
+    window.AudioContext = window.webkitAudioContext;
+  }
+
+  var safariShim = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    shimLocalStreamsAPI: shimLocalStreamsAPI,
+    shimRemoteStreamsAPI: shimRemoteStreamsAPI,
+    shimCallbacksAPI: shimCallbacksAPI,
+    shimGetUserMedia: shimGetUserMedia,
+    shimConstraints: shimConstraints,
+    shimRTCIceServerUrls: shimRTCIceServerUrls,
+    shimTrackEventTransceiver: shimTrackEventTransceiver,
+    shimCreateOfferLegacy: shimCreateOfferLegacy,
+    shimAudioContext: shimAudioContext
+  });
+
+  /*
+	 *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  function shimRTCIceCandidate(window) {
+    // foundation is arbitrarily chosen as an indicator for full support for
+    // https://w3c.github.io/webrtc-pc/#rtcicecandidate-interface
+    if (!window.RTCIceCandidate || (window.RTCIceCandidate && 'foundation' in
+      window.RTCIceCandidate.prototype)) {
+      return;
+    }
+
+    const NativeRTCIceCandidate = window.RTCIceCandidate;
+    window.RTCIceCandidate = function RTCIceCandidate(args) {
+      // Remove the a= which shouldn't be part of the candidate string.
+      if (typeof args === 'object' && args.candidate &&
+        args.candidate.indexOf('a=') === 0) {
+        args = JSON.parse(JSON.stringify(args));
+        args.candidate = args.candidate.substr(2);
+      }
+
+      if (args.candidate && args.candidate.length) {
+        // Augment the native candidate with the parsed fields.
+        const nativeCandidate = new NativeRTCIceCandidate(args);
+        const parsedCandidate = sdp.parseCandidate(args.candidate);
+        const augmentedCandidate = Object.assign(nativeCandidate,
+          parsedCandidate);
+
+        // Add a serializer that does not serialize the extra attributes.
+        augmentedCandidate.toJSON = function toJSON() {
+          return {
+            candidate: augmentedCandidate.candidate,
+            sdpMid: augmentedCandidate.sdpMid,
+            sdpMLineIndex: augmentedCandidate.sdpMLineIndex,
+            usernameFragment: augmentedCandidate.usernameFragment,
+          };
+        };
+        return augmentedCandidate;
+      }
+      return new NativeRTCIceCandidate(args);
+    };
+    window.RTCIceCandidate.prototype = NativeRTCIceCandidate.prototype;
+
+    // Hook up the augmented candidate in onicecandidate and
+    // addEventListener('icecandidate', ...)
+    wrapPeerConnectionEvent(window, 'icecandidate', e => {
+      if (e.candidate) {
+        Object.defineProperty(e, 'candidate', {
+          value: new window.RTCIceCandidate(e.candidate),
+          writable: 'false'
+        });
+      }
+      return e;
+    });
+  }
+
+  function shimMaxMessageSize(window, browserDetails) {
+    if (!window.RTCPeerConnection) {
+      return;
+    }
+
+    if (!('sctp' in window.RTCPeerConnection.prototype)) {
+      Object.defineProperty(window.RTCPeerConnection.prototype, 'sctp', {
+        get() {
+          return typeof this._sctp === 'undefined' ? null : this._sctp;
+        }
+      });
+    }
+
+    const sctpInDescription = function (description) {
+      if (!description || !description.sdp) {
+        return false;
+      }
+      const sections = sdp.splitSections(description.sdp);
+      sections.shift();
+      return sections.some(mediaSection => {
+        const mLine = sdp.parseMLine(mediaSection);
+        return mLine && mLine.kind === 'application'
+          && mLine.protocol.indexOf('SCTP') !== -1;
+      });
+    };
+
+    const getRemoteFirefoxVersion = function (description) {
+      // TODO: Is there a better solution for detecting Firefox?
+      const match = description.sdp.match(/mozilla...THIS_IS_SDPARTA-(\d+)/);
+      if (match === null || match.length < 2) {
+        return -1;
+      }
+      const version = parseInt(match[1], 10);
+      // Test for NaN (yes, this is ugly)
+      return version !== version ? -1 : version;
+    };
+
+    const getCanSendMaxMessageSize = function (remoteIsFirefox) {
+      // Every implementation we know can send at least 64 KiB.
+      // Note: Although Chrome is technically able to send up to 256 KiB, the
+      //       data does not reach the other peer reliably.
+      //       See: https://bugs.chromium.org/p/webrtc/issues/detail?id=8419
+      let canSendMaxMessageSize = 65536;
+      if (browserDetails.browser === 'firefox') {
+        if (browserDetails.version < 57) {
+          if (remoteIsFirefox === -1) {
+            // FF < 57 will send in 16 KiB chunks using the deprecated PPID
+            // fragmentation.
+            canSendMaxMessageSize = 16384;
+          } else {
+            // However, other FF (and RAWRTC) can reassemble PPID-fragmented
+            // messages. Thus, supporting ~2 GiB when sending.
+            canSendMaxMessageSize = 2147483637;
+          }
+        } else if (browserDetails.version < 60) {
+          // Currently, all FF >= 57 will reset the remote maximum message size
+          // to the default value when a data channel is created at a later
+          // stage. :(
+          // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1426831
+          canSendMaxMessageSize =
+            browserDetails.version === 57 ? 65535 : 65536;
+        } else {
+          // FF >= 60 supports sending ~2 GiB
+          canSendMaxMessageSize = 2147483637;
+        }
+      }
+      return canSendMaxMessageSize;
+    };
+
+    const getMaxMessageSize = function (description, remoteIsFirefox) {
+      // Note: 65536 bytes is the default value from the SDP spec. Also,
+      //       every implementation we know supports receiving 65536 bytes.
+      let maxMessageSize = 65536;
+
+      // FF 57 has a slightly incorrect default remote max message size, so
+      // we need to adjust it here to avoid a failure when sending.
+      // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1425697
+      if (browserDetails.browser === 'firefox'
+        && browserDetails.version === 57) {
+        maxMessageSize = 65535;
+      }
+
+      const match = sdp.matchPrefix(description.sdp,
+        'a=max-message-size:');
+      if (match.length > 0) {
+        maxMessageSize = parseInt(match[0].substr(19), 10);
+      } else if (browserDetails.browser === 'firefox' &&
+        remoteIsFirefox !== -1) {
+        // If the maximum message size is not present in the remote SDP and
+        // both local and remote are Firefox, the remote peer can receive
+        // ~2 GiB.
+        maxMessageSize = 2147483637;
+      }
+      return maxMessageSize;
+    };
+
+    const origSetRemoteDescription =
+      window.RTCPeerConnection.prototype.setRemoteDescription;
+    window.RTCPeerConnection.prototype.setRemoteDescription =
+      function setRemoteDescription() {
+        this._sctp = null;
+        // Chrome decided to not expose .sctp in plan-b mode.
+        // As usual, adapter.js has to do an 'ugly worakaround'
+        // to cover up the mess.
+        if (browserDetails.browser === 'chrome' && browserDetails.version >= 76) {
+          const {sdpSemantics} = this.getConfiguration();
+          if (sdpSemantics === 'plan-b') {
+            Object.defineProperty(this, 'sctp', {
+              get() {
+                return typeof this._sctp === 'undefined' ? null : this._sctp;
+              },
+              enumerable: true,
+              configurable: true,
+            });
+          }
+        }
+
+        if (sctpInDescription(arguments[0])) {
+          // Check if the remote is FF.
+          const isFirefox = getRemoteFirefoxVersion(arguments[0]);
+
+          // Get the maximum message size the local peer is capable of sending
+          const canSendMMS = getCanSendMaxMessageSize(isFirefox);
+
+          // Get the maximum message size of the remote peer.
+          const remoteMMS = getMaxMessageSize(arguments[0], isFirefox);
+
+          // Determine final maximum message size
+          let maxMessageSize;
+          if (canSendMMS === 0 && remoteMMS === 0) {
+            maxMessageSize = Number.POSITIVE_INFINITY;
+          } else if (canSendMMS === 0 || remoteMMS === 0) {
+            maxMessageSize = Math.max(canSendMMS, remoteMMS);
+          } else {
+            maxMessageSize = Math.min(canSendMMS, remoteMMS);
+          }
+
+          // Create a dummy RTCSctpTransport object and the 'maxMessageSize'
+          // attribute.
+          const sctp = {};
+          Object.defineProperty(sctp, 'maxMessageSize', {
+            get() {
+              return maxMessageSize;
+            }
+          });
+          this._sctp = sctp;
+        }
+
+        return origSetRemoteDescription.apply(this, arguments);
+      };
+  }
+
+  function shimSendThrowTypeError(window) {
+    if (!(window.RTCPeerConnection &&
+      'createDataChannel' in window.RTCPeerConnection.prototype)) {
+      return;
+    }
+
+    // Note: Although Firefox >= 57 has a native implementation, the maximum
+    //       message size can be reset for all data channels at a later stage.
+    //       See: https://bugzilla.mozilla.org/show_bug.cgi?id=1426831
+
+    function wrapDcSend(dc, pc) {
+      const origDataChannelSend = dc.send;
+      dc.send = function send() {
+        const data = arguments[0];
+        const length = data.length || data.size || data.byteLength;
+        if (dc.readyState === 'open' &&
+          pc.sctp && length > pc.sctp.maxMessageSize) {
+          throw new TypeError('Message too large (can send a maximum of ' +
+            pc.sctp.maxMessageSize + ' bytes)');
+        }
+        return origDataChannelSend.apply(dc, arguments);
+      };
+    }
+
+    const origCreateDataChannel =
+      window.RTCPeerConnection.prototype.createDataChannel;
+    window.RTCPeerConnection.prototype.createDataChannel =
+      function createDataChannel() {
+        const dataChannel = origCreateDataChannel.apply(this, arguments);
+        wrapDcSend(dataChannel, this);
+        return dataChannel;
+      };
+    wrapPeerConnectionEvent(window, 'datachannel', e => {
+      wrapDcSend(e.channel, e.target);
+      return e;
+    });
+  }
+
+
+  /* shims RTCConnectionState by pretending it is the same as iceConnectionState.
+	 * See https://bugs.chromium.org/p/webrtc/issues/detail?id=6145#c12
+	 * for why this is a valid hack in Chrome. In Firefox it is slightly incorrect
+	 * since DTLS failures would be hidden. See
+	 * https://bugzilla.mozilla.org/show_bug.cgi?id=1265827
+	 * for the Firefox tracking bug.
+	 */
+  function shimConnectionState(window) {
+    if (!window.RTCPeerConnection ||
+      'connectionState' in window.RTCPeerConnection.prototype) {
+      return;
+    }
+    const proto = window.RTCPeerConnection.prototype;
+    Object.defineProperty(proto, 'connectionState', {
+      get() {
+        return {
+          completed: 'connected',
+          checking: 'connecting'
+        }[this.iceConnectionState] || this.iceConnectionState;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(proto, 'onconnectionstatechange', {
+      get() {
+        return this._onconnectionstatechange || null;
+      },
+      set(cb) {
+        if (this._onconnectionstatechange) {
+          this.removeEventListener('connectionstatechange',
+            this._onconnectionstatechange);
+          delete this._onconnectionstatechange;
+        }
+        if (cb) {
+          this.addEventListener('connectionstatechange',
+            this._onconnectionstatechange = cb);
+        }
+      },
+      enumerable: true,
+      configurable: true
+    });
+
+    ['setLocalDescription', 'setRemoteDescription'].forEach((method) => {
+      const origMethod = proto[method];
+      proto[method] = function () {
+        if (!this._connectionstatechangepoly) {
+          this._connectionstatechangepoly = e => {
+            const pc = e.target;
+            if (pc._lastConnectionState !== pc.connectionState) {
+              pc._lastConnectionState = pc.connectionState;
+              const newEvent = new Event('connectionstatechange', e);
+              pc.dispatchEvent(newEvent);
+            }
+            return e;
+          };
+          this.addEventListener('iceconnectionstatechange',
+            this._connectionstatechangepoly);
+        }
+        return origMethod.apply(this, arguments);
+      };
+    });
+  }
+
+  function removeExtmapAllowMixed(window, browserDetails) {
+    /* remove a=extmap-allow-mixed for webrtc.org < M71 */
+    if (!window.RTCPeerConnection) {
+      return;
+    }
+    if (browserDetails.browser === 'chrome' && browserDetails.version >= 71) {
+      return;
+    }
+    if (browserDetails.browser === 'safari' && browserDetails.version >= 605) {
+      return;
+    }
+    const nativeSRD = window.RTCPeerConnection.prototype.setRemoteDescription;
+    window.RTCPeerConnection.prototype.setRemoteDescription =
+      function setRemoteDescription(desc) {
+        if (desc && desc.sdp && desc.sdp.indexOf('\na=extmap-allow-mixed') !== -1) {
+          const sdp = desc.sdp.split('\n').filter((line) => {
+            return line.trim() !== 'a=extmap-allow-mixed';
+          }).join('\n');
+          // Safari enforces read-only-ness of RTCSessionDescription fields.
+          if (window.RTCSessionDescription &&
+            desc instanceof window.RTCSessionDescription) {
+            arguments[0] = new window.RTCSessionDescription({
+              type: desc.type,
+              sdp,
+            });
+          } else {
+            desc.sdp = sdp;
+          }
+        }
+        return nativeSRD.apply(this, arguments);
+      };
+  }
+
+  function shimAddIceCandidateNullOrEmpty(window, browserDetails) {
+    // Support for addIceCandidate(null or undefined)
+    // as well as addIceCandidate({candidate: "", ...})
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=978582
+    // Note: must be called before other polyfills which change the signature.
+    if (!(window.RTCPeerConnection && window.RTCPeerConnection.prototype)) {
+      return;
+    }
+    const nativeAddIceCandidate =
+      window.RTCPeerConnection.prototype.addIceCandidate;
+    if (!nativeAddIceCandidate || nativeAddIceCandidate.length === 0) {
+      return;
+    }
+    window.RTCPeerConnection.prototype.addIceCandidate =
+      function addIceCandidate() {
+        if (!arguments[0]) {
+          if (arguments[1]) {
+            arguments[1].apply(null);
+          }
+          return Promise.resolve();
+        }
+        // Firefox 68+ emits and processes {candidate: "", ...}, ignore
+        // in older versions.
+        // Native support for ignoring exists for Chrome M77+.
+        // Safari ignores as well, exact version unknown but works in the same
+        // version that also ignores addIceCandidate(null).
+        if (((browserDetails.browser === 'chrome' && browserDetails.version < 78)
+          || (browserDetails.browser === 'firefox'
+            && browserDetails.version < 68)
+          || (browserDetails.browser === 'safari'))
+          && arguments[0] && arguments[0].candidate === '') {
+          return Promise.resolve();
+        }
+        return nativeAddIceCandidate.apply(this, arguments);
+      };
+  }
+
+  var commonShim = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    shimRTCIceCandidate: shimRTCIceCandidate,
+    shimMaxMessageSize: shimMaxMessageSize,
+    shimSendThrowTypeError: shimSendThrowTypeError,
+    shimConnectionState: shimConnectionState,
+    removeExtmapAllowMixed: removeExtmapAllowMixed,
+    shimAddIceCandidateNullOrEmpty: shimAddIceCandidateNullOrEmpty
+  });
+
+  /*
+	 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  // Shimming starts here.
+  function adapterFactory({window} = {}, options = {
+    shimChrome: true,
+    shimFirefox: true,
+    shimEdge: true,
+    shimSafari: true,
+  }) {
+    // Utils.
+    const logging = log$1;
+    const browserDetails = detectBrowser(window);
+
+    const adapter = {
+      browserDetails,
+      commonShim,
+      extractVersion: extractVersion,
+      disableLog: disableLog,
+      disableWarnings: disableWarnings
+    };
+
+    // Shim browser if found.
+    switch (browserDetails.browser) {
+      case 'chrome':
+        if (!chromeShim || !shimPeerConnection$2 ||
+          !options.shimChrome) {
+          logging('Chrome shim is not included in this adapter release.');
+          return adapter;
+        }
+        if (browserDetails.version === null) {
+          logging('Chrome shim can not determine version, not shimming.');
+          return adapter;
+        }
+        logging('adapter.js shimming chrome.');
+        // Export to the adapter global object visible in the browser.
+        adapter.browserShim = chromeShim;
+
+        // Must be called before shimPeerConnection.
+        shimAddIceCandidateNullOrEmpty(window, browserDetails);
+
+        shimGetUserMedia$3(window, browserDetails);
+        shimMediaStream(window);
+        shimPeerConnection$2(window, browserDetails);
+        shimOnTrack$1(window);
+        shimAddTrackRemoveTrack(window, browserDetails);
+        shimGetSendersWithDtmf(window);
+        shimGetStats(window);
+        shimSenderReceiverGetStats(window);
+        fixNegotiationNeeded(window, browserDetails);
+
+        shimRTCIceCandidate(window);
+        shimConnectionState(window);
+        shimMaxMessageSize(window, browserDetails);
+        shimSendThrowTypeError(window);
+        removeExtmapAllowMixed(window, browserDetails);
+        break;
+      case 'firefox':
+        if (!firefoxShim || !shimPeerConnection ||
+          !options.shimFirefox) {
+          logging('Firefox shim is not included in this adapter release.');
+          return adapter;
+        }
+        logging('adapter.js shimming firefox.');
+        // Export to the adapter global object visible in the browser.
+        adapter.browserShim = firefoxShim;
+
+        // Must be called before shimPeerConnection.
+        shimAddIceCandidateNullOrEmpty(window, browserDetails);
+
+        shimGetUserMedia$1(window, browserDetails);
+        shimPeerConnection(window, browserDetails);
+        shimOnTrack(window);
+        shimRemoveStream(window);
+        shimSenderGetStats(window);
+        shimReceiverGetStats(window);
+        shimRTCDataChannel(window);
+        shimAddTransceiver(window);
+        shimGetParameters(window);
+        shimCreateOffer(window);
+        shimCreateAnswer(window);
+
+        shimRTCIceCandidate(window);
+        shimConnectionState(window);
+        shimMaxMessageSize(window, browserDetails);
+        shimSendThrowTypeError(window);
+        break;
+      case 'edge':
+        if (!edgeShim || !shimPeerConnection$1 || !options.shimEdge) {
+          logging('MS edge shim is not included in this adapter release.');
+          return adapter;
+        }
+        logging('adapter.js shimming edge.');
+        // Export to the adapter global object visible in the browser.
+        adapter.browserShim = edgeShim;
+
+        shimGetUserMedia$2(window);
+        shimGetDisplayMedia$1(window);
+        shimPeerConnection$1(window, browserDetails);
+        shimReplaceTrack(window);
+
+        // the edge shim implements the full RTCIceCandidate object.
+
+        shimMaxMessageSize(window, browserDetails);
+        shimSendThrowTypeError(window);
+        break;
+      case 'safari':
+        if (!safariShim || !options.shimSafari) {
+          logging('Safari shim is not included in this adapter release.');
+          return adapter;
+        }
+        logging('adapter.js shimming safari.');
+        // Export to the adapter global object visible in the browser.
+        adapter.browserShim = safariShim;
+
+        // Must be called before shimCallbackAPI.
+        shimAddIceCandidateNullOrEmpty(window, browserDetails);
+
+        shimRTCIceServerUrls(window);
+        shimCreateOfferLegacy(window);
+        shimCallbacksAPI(window);
+        shimLocalStreamsAPI(window);
+        shimRemoteStreamsAPI(window);
+        shimTrackEventTransceiver(window);
+        shimGetUserMedia(window);
+        shimAudioContext(window);
+
+        shimRTCIceCandidate(window);
+        shimMaxMessageSize(window, browserDetails);
+        shimSendThrowTypeError(window);
+        removeExtmapAllowMixed(window, browserDetails);
+        break;
+      default:
+        logging('Unsupported browser!');
+        break;
+    }
+
+    return adapter;
+  }
+
+  /*
+	 *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+	 *
+	 *  Use of this source code is governed by a BSD-style license
+	 *  that can be found in the LICENSE file in the root of the source
+	 *  tree.
+	 */
+
+  adapterFactory({window: typeof window === 'undefined' ? undefined : window});
+
+  /**
+   * @class AudioTrackConstraints
+   * @classDesc Constraints for creating an audio MediaStreamTrack.
+   * @memberof Owt.Base
+   * @constructor
+   * @param {Owt.Base.AudioSourceInfo} source Source info of this audio track.
+   */
+
+  class AudioTrackConstraints {
+    // eslint-disable-next-line require-jsdoc
+    constructor(source) {
+      if (!Object.values(AudioSourceInfo).some(v => v === source)) {
+        throw new TypeError('Invalid source.');
+      }
+      /**
+       * @member {string} source
+       * @memberof Owt.Base.AudioTrackConstraints
+       * @desc Values could be "mic", "screen-cast", "file" or "mixed".
+       * @instance
+       */
+
+
+      this.source = source;
+      /**
+       * @member {string} deviceId
+       * @memberof Owt.Base.AudioTrackConstraints
+       * @desc Do not provide deviceId if source is not "mic".
+       * @instance
+       * @see https://w3c.github.io/mediacapture-main/#def-constraint-deviceId
+       */
+
+      this.deviceId = undefined;
+    }
+
+  }
+
+  /**
+   * @class VideoTrackConstraints
+   * @classDesc Constraints for creating a video MediaStreamTrack.
+   * @memberof Owt.Base
+   * @constructor
+   * @param {Owt.Base.VideoSourceInfo} source Source info of this video track.
+   */
+
+  class VideoTrackConstraints {
+    // eslint-disable-next-line require-jsdoc
+    constructor(source) {
+      if (!Object.values(VideoSourceInfo).some(v => v === source)) {
+        throw new TypeError('Invalid source.');
+      }
+      /**
+       * @member {string} source
+       * @memberof Owt.Base.VideoTrackConstraints
+       * @desc Values could be "camera", "screen-cast", "file" or "mixed".
+       * @instance
+       */
+
+
+      this.source = source;
+      /**
+       * @member {string} deviceId
+       * @memberof Owt.Base.VideoTrackConstraints
+       * @desc Do not provide deviceId if source is not "camera".
+       * @instance
+       * @see https://w3c.github.io/mediacapture-main/#def-constraint-deviceId
+       */
+
+      this.deviceId = undefined;
+      /**
+       * @member {Owt.Base.Resolution} resolution
+       * @memberof Owt.Base.VideoTrackConstraints
+       * @instance
+       */
+
+      this.resolution = undefined;
+      /**
+       * @member {number} frameRate
+       * @memberof Owt.Base.VideoTrackConstraints
+       * @instance
+       */
+
+      this.frameRate = undefined;
+    }
+
+  }
+
+  /**
+   * @class StreamConstraints
+   * @classDesc Constraints for creating a MediaStream from screen mic and camera.
+   * @memberof Owt.Base
+   * @constructor
+   * @param {?Owt.Base.AudioTrackConstraints} audioConstraints
+   * @param {?Owt.Base.VideoTrackConstraints} videoConstraints
+   */
+
+  class StreamConstraints {
+    // eslint-disable-next-line require-jsdoc
+    constructor(audioConstraints = false, videoConstraints = false) {
+      /**
+       * @member {Owt.Base.MediaStreamTrackDeviceConstraintsForAudio} audio
+       * @memberof Owt.Base.MediaStreamDeviceConstraints
+       * @instance
+       */
+      this.audio = audioConstraints;
+      /**
+       * @member {Owt.Base.MediaStreamTrackDeviceConstraintsForVideo} Video
+       * @memberof Owt.Base.MediaStreamDeviceConstraints
+       * @instance
+       */
+
+      this.video = videoConstraints;
+    }
+
+  } // eslint-disable-next-line require-jsdoc
+
+  function isVideoConstrainsForScreenCast(constraints) {
+    return typeof constraints.video === 'object' && constraints.video.source === VideoSourceInfo.SCREENCAST;
+  }
+
+  /**
+   * @class MediaStreamFactory
+   * @classDesc A factory to create MediaStream. You can also create MediaStream by yourself.
+   * @memberof Owt.Base
+   */
+
+
+  class MediaStreamFactory {
+    /**
+     * @function createMediaStream
+     * @static
+     * @desc Create a MediaStream with given constraints. If you want to create a MediaStream for screen cast, please make sure both audio and video's source are "screen-cast".
+     * @memberof Owt.Base.MediaStreamFactory
+     * @return {Promise<MediaStream, Error>} Return a promise that is resolved when stream is successfully created, or rejected if one of the following error happened:
+     * - One or more parameters cannot be satisfied.
+     * - Specified device is busy.
+     * - Cannot obtain necessary permission or operation is canceled by user.
+     * - Video source is screen cast, while audio source is not.
+     * - Audio source is screen cast, while video source is disabled.
+     * @param {Owt.Base.StreamConstraints} constraints
+     */
+    static createMediaStream(constraints) {
+      if (typeof constraints !== 'object' || !constraints.audio && !constraints.video) {
+        return Promise.reject(new TypeError('Invalid constrains'));
+      }
+
+      if (!isVideoConstrainsForScreenCast(constraints) && typeof constraints.audio === 'object' && constraints.audio.source === AudioSourceInfo.SCREENCAST) {
+        return Promise.reject(new TypeError('Cannot share screen without video.'));
+      }
+
+      if (isVideoConstrainsForScreenCast(constraints) && !isChrome() && !isFirefox()) {
+        return Promise.reject(new TypeError('Screen sharing only supports Chrome and Firefox.'));
+      }
+
+      if (isVideoConstrainsForScreenCast(constraints) && typeof constraints.audio === 'object' && constraints.audio.source !== AudioSourceInfo.SCREENCAST) {
+        return Promise.reject(new TypeError('Cannot capture video from screen cast while capture audio from' + ' other source.'));
+      } // Check and convert constraints.
+
+
+      if (!constraints.audio && !constraints.video) {
+        return Promise.reject(new TypeError('At least one of audio and video must be requested.'));
+      }
+
+      const mediaConstraints = Object.create({});
+
+      if (typeof constraints.audio === 'object' && constraints.audio.source === AudioSourceInfo.MIC) {
+        mediaConstraints.audio = Object.create({});
+
+        if (isEdge()) {
+          mediaConstraints.audio.deviceId = constraints.audio.deviceId;
+        } else {
+          mediaConstraints.audio.deviceId = {
+            exact: constraints.audio.deviceId
+          };
+        }
+      } else {
+        if (constraints.audio.source === AudioSourceInfo.SCREENCAST) {
+          mediaConstraints.audio = true;
+        } else {
+          mediaConstraints.audio = constraints.audio;
+        }
+      }
+
+      if (typeof constraints.video === 'object') {
+        mediaConstraints.video = Object.create({});
+
+        if (typeof constraints.video.frameRate === 'number') {
+          mediaConstraints.video.frameRate = constraints.video.frameRate;
+        }
+
+        if (constraints.video.resolution && constraints.video.resolution.width && constraints.video.resolution.height) {
+          if (constraints.video.source === VideoSourceInfo.SCREENCAST) {
+            mediaConstraints.video.width = constraints.video.resolution.width;
+            mediaConstraints.video.height = constraints.video.resolution.height;
+          } else {
+            mediaConstraints.video.width = Object.create({});
+            mediaConstraints.video.width.exact = constraints.video.resolution.width;
+            mediaConstraints.video.height = Object.create({});
+            mediaConstraints.video.height.exact = constraints.video.resolution.height;
+          }
+        }
+
+        if (typeof constraints.video.deviceId === 'string') {
+          mediaConstraints.video.deviceId = {
+            exact: constraints.video.deviceId
+          };
+        }
+
+        if (isFirefox() && constraints.video.source === VideoSourceInfo.SCREENCAST) {
+          mediaConstraints.video.mediaSource = 'screen';
+        }
+      } else {
+        mediaConstraints.video = constraints.video;
+      }
+
+      if (isVideoConstrainsForScreenCast(constraints)) {
+        return navigator.mediaDevices.getDisplayMedia(mediaConstraints);
+      } else {
+        return navigator.mediaDevices.getUserMedia(mediaConstraints);
+      }
+    }
+
+  }
+
+  // Copyright (C) <2018> Intel Corporation
+
+  var media = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AudioTrackConstraints: AudioTrackConstraints,
+    VideoTrackConstraints: VideoTrackConstraints,
+    StreamConstraints: StreamConstraints,
+    MediaStreamFactory: MediaStreamFactory,
+    AudioSourceInfo: AudioSourceInfo,
+    VideoSourceInfo: VideoSourceInfo,
+    TrackKind: TrackKind,
+    Resolution: Resolution
+  });
+
+  let logger;
+  let errorLogger;
+
+  function setLogger() {
+    /*eslint-disable */
+    logger = console.log;
+    errorLogger = console.error;
+    /*eslint-enable */
+  }
+
+  function log(message, ...optionalParams) {
+    if (logger) {
+      logger(message, ...optionalParams);
+    }
+  }
+
+  function error(message, ...optionalParams) {
+    if (errorLogger) {
+      errorLogger(message, ...optionalParams);
+    }
+  }
+
+  class Event$1 {
+    constructor(type) {
+      this.listener = {};
+      this.type = type | '';
+    }
+
+    on(event, fn) {
+      if (!this.listener[event]) {
+        this.listener[event] = [];
+      }
+
+      this.listener[event].push(fn);
+      return true;
+    }
+
+    off(event, fn) {
+      if (this.listener[event]) {
+        var index = this.listener[event].indexOf(fn);
+
+        if (index > -1) {
+          this.listener[event].splice(index, 1);
+        }
+
+        return true;
+      }
+
+      return false;
+    }
+
+    offAll() {
+      this.listener = {};
+    }
+
+    dispatch(event, data) {
+      if (this.listener[event]) {
+        this.listener[event].map(each => {
+          each.apply(null, [data]);
+        });
+        return true;
+      }
+
+      return false;
+    }
+
+  }
+
+  var bind = function bind(fn, thisArg) {
+    return function wrap() {
+      var args = new Array(arguments.length);
+      for (var i = 0; i < args.length; i++) {
+        args[i] = arguments[i];
+      }
+      return fn.apply(thisArg, args);
+    };
+  };
+
+  /*global toString:true*/
+
+  // utils is a library of generic helper functions non-specific to axios
+
+  var toString = Object.prototype.toString;
+
+  /**
+   * Determine if a value is an Array
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is an Array, otherwise false
+   */
+  function isArray(val) {
+    return toString.call(val) === '[object Array]';
+  }
+
+  /**
+   * Determine if a value is undefined
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if the value is undefined, otherwise false
+   */
+  function isUndefined(val) {
+    return typeof val === 'undefined';
+  }
+
+  /**
+   * Determine if a value is a Buffer
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is a Buffer, otherwise false
+   */
+  function isBuffer(val) {
+    return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
+      && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);
+  }
+
+  /**
+   * Determine if a value is an ArrayBuffer
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is an ArrayBuffer, otherwise false
+   */
+  function isArrayBuffer(val) {
+    return toString.call(val) === '[object ArrayBuffer]';
+  }
+
+  /**
+   * Determine if a value is a FormData
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is an FormData, otherwise false
+   */
+  function isFormData(val) {
+    return (typeof FormData !== 'undefined') && (val instanceof FormData);
+  }
+
+  /**
+   * Determine if a value is a view on an ArrayBuffer
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
+   */
+  function isArrayBufferView(val) {
+    var result;
+    if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
+      result = ArrayBuffer.isView(val);
+    } else {
+      result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
+    }
+    return result;
+  }
+
+  /**
+   * Determine if a value is a String
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is a String, otherwise false
+   */
+  function isString(val) {
+    return typeof val === 'string';
+  }
+
+  /**
+   * Determine if a value is a Number
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is a Number, otherwise false
+   */
+  function isNumber(val) {
+    return typeof val === 'number';
+  }
+
+  /**
+   * Determine if a value is an Object
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is an Object, otherwise false
+   */
+  function isObject(val) {
+    return val !== null && typeof val === 'object';
+  }
+
+  /**
+   * Determine if a value is a plain Object
+   *
+   * @param {Object} val The value to test
+   * @return {boolean} True if value is a plain Object, otherwise false
+   */
+  function isPlainObject(val) {
+    if (toString.call(val) !== '[object Object]') {
+      return false;
+    }
+
+    var prototype = Object.getPrototypeOf(val);
+    return prototype === null || prototype === Object.prototype;
+  }
+
+  /**
+   * Determine if a value is a Date
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is a Date, otherwise false
+   */
+  function isDate(val) {
+    return toString.call(val) === '[object Date]';
+  }
+
+  /**
+   * Determine if a value is a File
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is a File, otherwise false
+   */
+  function isFile(val) {
+    return toString.call(val) === '[object File]';
+  }
+
+  /**
+   * Determine if a value is a Blob
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is a Blob, otherwise false
+   */
+  function isBlob(val) {
+    return toString.call(val) === '[object Blob]';
+  }
+
+  /**
+   * Determine if a value is a Function
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is a Function, otherwise false
+   */
+  function isFunction(val) {
+    return toString.call(val) === '[object Function]';
+  }
+
+  /**
+   * Determine if a value is a Stream
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is a Stream, otherwise false
+   */
+  function isStream(val) {
+    return isObject(val) && isFunction(val.pipe);
+  }
+
+  /**
+   * Determine if a value is a URLSearchParams object
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is a URLSearchParams object, otherwise false
+   */
+  function isURLSearchParams(val) {
+    return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
+  }
+
+  /**
+   * Trim excess whitespace off the beginning and end of a string
+   *
+   * @param {String} str The String to trim
+   * @returns {String} The String freed of excess whitespace
+   */
+  function trim(str) {
+    return str.replace(/^\s*/, '').replace(/\s*$/, '');
+  }
+
+  /**
+   * Determine if we're running in a standard browser environment
+   *
+   * This allows axios to run in a web worker, and react-native.
+   * Both environments support XMLHttpRequest, but not fully standard globals.
+   *
+   * web workers:
+   *  typeof window -> undefined
+   *  typeof document -> undefined
+   *
+   * react-native:
+   *  navigator.product -> 'ReactNative'
+   * nativescript
+   *  navigator.product -> 'NativeScript' or 'NS'
+   */
+  function isStandardBrowserEnv() {
+    if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
+      navigator.product === 'NativeScript' ||
+      navigator.product === 'NS')) {
+      return false;
+    }
+    return (
+      typeof window !== 'undefined' &&
+      typeof document !== 'undefined'
+    );
+  }
+
+  /**
+   * Iterate over an Array or an Object invoking a function for each item.
+   *
+   * If `obj` is an Array callback will be called passing
+   * the value, index, and complete array for each item.
+   *
+   * If 'obj' is an Object callback will be called passing
+   * the value, key, and complete object for each property.
+   *
+   * @param {Object|Array} obj The object to iterate
+   * @param {Function} fn The callback to invoke for each item
+   */
+  function forEach(obj, fn) {
+    // Don't bother if no value provided
+    if (obj === null || typeof obj === 'undefined') {
+      return;
+    }
+
+    // Force an array if not already something iterable
+    if (typeof obj !== 'object') {
+      /*eslint no-param-reassign:0*/
+      obj = [obj];
+    }
+
+    if (isArray(obj)) {
+      // Iterate over array values
+      for (var i = 0, l = obj.length; i < l; i++) {
+        fn.call(null, obj[i], i, obj);
+      }
+    } else {
+      // Iterate over object keys
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          fn.call(null, obj[key], key, obj);
+        }
+      }
+    }
+  }
+
+  /**
+   * Accepts varargs expecting each argument to be an object, then
+   * immutably merges the properties of each object and returns result.
+   *
+   * When multiple objects contain the same key the later object in
+   * the arguments list will take precedence.
+   *
+   * Example:
+   *
+   * ```js
+   * var result = merge({foo: 123}, {foo: 456});
+   * console.log(result.foo); // outputs 456
+   * ```
+   *
+   * @param {Object} obj1 Object to merge
+   * @returns {Object} Result of all merge properties
+   */
+  function merge(/* obj1, obj2, obj3, ... */) {
+    var result = {};
+
+    function assignValue(val, key) {
+      if (isPlainObject(result[key]) && isPlainObject(val)) {
+        result[key] = merge(result[key], val);
+      } else if (isPlainObject(val)) {
+        result[key] = merge({}, val);
+      } else if (isArray(val)) {
+        result[key] = val.slice();
+      } else {
+        result[key] = val;
+      }
+    }
+
+    for (var i = 0, l = arguments.length; i < l; i++) {
+      forEach(arguments[i], assignValue);
+    }
+    return result;
+  }
+
+  /**
+   * Extends object a by mutably adding to it the properties of object b.
+   *
+   * @param {Object} a The object to be extended
+   * @param {Object} b The object to copy properties from
+   * @param {Object} thisArg The object to bind function to
+   * @return {Object} The resulting value of object a
+   */
+  function extend(a, b, thisArg) {
+    forEach(b, function assignValue(val, key) {
+      if (thisArg && typeof val === 'function') {
+        a[key] = bind(val, thisArg);
+      } else {
+        a[key] = val;
+      }
+    });
+    return a;
+  }
+
+  /**
+   * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+   *
+   * @param {string} content with BOM
+   * @return {string} content value without BOM
+   */
+  function stripBOM(content) {
+    if (content.charCodeAt(0) === 0xFEFF) {
+      content = content.slice(1);
+    }
+    return content;
+  }
+
+  var utils = {
+    isArray: isArray,
+    isArrayBuffer: isArrayBuffer,
+    isBuffer: isBuffer,
+    isFormData: isFormData,
+    isArrayBufferView: isArrayBufferView,
+    isString: isString,
+    isNumber: isNumber,
+    isObject: isObject,
+    isPlainObject: isPlainObject,
+    isUndefined: isUndefined,
+    isDate: isDate,
+    isFile: isFile,
+    isBlob: isBlob,
+    isFunction: isFunction,
+    isStream: isStream,
+    isURLSearchParams: isURLSearchParams,
+    isStandardBrowserEnv: isStandardBrowserEnv,
+    forEach: forEach,
+    merge: merge,
+    extend: extend,
+    trim: trim,
+    stripBOM: stripBOM
+  };
+
+  function encode(val) {
+    return encodeURIComponent(val).replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, '+').replace(/%5B/gi, '[').replace(/%5D/gi, ']');
+  }
+
+  /**
+   * Build a URL by appending params to the end
+   *
+   * @param {string} url The base of the url (e.g., http://www.google.com)
+   * @param {object} [params] The params to be appended
+   * @returns {string} The formatted url
+   */
+  var buildURL = function buildURL(url, params, paramsSerializer) {
+    /*eslint no-param-reassign:0*/
+    if (!params) {
+      return url;
+    }
+
+    var serializedParams;
+    if (paramsSerializer) {
+      serializedParams = paramsSerializer(params);
+    } else if (utils.isURLSearchParams(params)) {
+      serializedParams = params.toString();
+    } else {
+      var parts = [];
+
+      utils.forEach(params, function serialize(val, key) {
+        if (val === null || typeof val === 'undefined') {
+          return;
+        }
+
+        if (utils.isArray(val)) {
+          key = key + '[]';
+        } else {
+          val = [val];
+        }
+
+        utils.forEach(val, function parseValue(v) {
+          if (utils.isDate(v)) {
+            v = v.toISOString();
+          } else if (utils.isObject(v)) {
+            v = JSON.stringify(v);
+          }
+          parts.push(encode(key) + '=' + encode(v));
+        });
+      });
+
+      serializedParams = parts.join('&');
+    }
+
+    if (serializedParams) {
+      var hashmarkIndex = url.indexOf('#');
+      if (hashmarkIndex !== -1) {
+        url = url.slice(0, hashmarkIndex);
+      }
+
+      url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
+    }
+
+    return url;
+  };
+
+  function InterceptorManager() {
+    this.handlers = [];
+  }
+
+  /**
+   * Add a new interceptor to the stack
+   *
+   * @param {Function} fulfilled The function to handle `then` for a `Promise`
+   * @param {Function} rejected The function to handle `reject` for a `Promise`
+   *
+   * @return {Number} An ID used to remove interceptor later
+   */
+  InterceptorManager.prototype.use = function use(fulfilled, rejected) {
+    this.handlers.push({
+      fulfilled: fulfilled,
+      rejected: rejected
+    });
+    return this.handlers.length - 1;
+  };
+
+  /**
+   * Remove an interceptor from the stack
+   *
+   * @param {Number} id The ID that was returned by `use`
+   */
+  InterceptorManager.prototype.eject = function eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
+  };
+
+  /**
+   * Iterate over all the registered interceptors
+   *
+   * This method is particularly useful for skipping over any
+   * interceptors that may have become `null` calling `eject`.
+   *
+   * @param {Function} fn The function to call for each interceptor
+   */
+  InterceptorManager.prototype.forEach = function forEach(fn) {
+    utils.forEach(this.handlers, function forEachHandler(h) {
+      if (h !== null) {
+        fn(h);
+      }
+    });
+  };
+
+  var InterceptorManager_1 = InterceptorManager;
+
+  /**
+   * Transform the data for a request or a response
+   *
+   * @param {Object|String} data The data to be transformed
+   * @param {Array} headers The headers for the request or response
+   * @param {Array|Function} fns A single function or Array of functions
+   * @returns {*} The resulting transformed data
+   */
+  var transformData = function transformData(data, headers, fns) {
+    /*eslint no-param-reassign:0*/
+    utils.forEach(fns, function transform(fn) {
+      data = fn(data, headers);
+    });
+
+    return data;
+  };
+
+  var isCancel = function isCancel(value) {
+    return !!(value && value.__CANCEL__);
+  };
+
+  var normalizeHeaderName = function normalizeHeaderName(headers, normalizedName) {
+    utils.forEach(headers, function processHeader(value, name) {
+      if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
+        headers[normalizedName] = value;
+        delete headers[name];
+      }
+    });
+  };
+
+  /**
+   * Update an Error with the specified config, error code, and response.
+   *
+   * @param {Error} error The error to update.
+   * @param {Object} config The config.
+   * @param {string} [code] The error code (for example, 'ECONNABORTED').
+   * @param {Object} [request] The request.
+   * @param {Object} [response] The response.
+   * @returns {Error} The error.
+   */
+  var enhanceError = function enhanceError(error, config, code, request, response) {
+    error.config = config;
+    if (code) {
+      error.code = code;
+    }
+
+    error.request = request;
+    error.response = response;
+    error.isAxiosError = true;
+
+    error.toJSON = function toJSON() {
+      return {
+        // Standard
+        message: this.message,
+        name: this.name,
+        // Microsoft
+        description: this.description,
+        number: this.number,
+        // Mozilla
+        fileName: this.fileName,
+        lineNumber: this.lineNumber,
+        columnNumber: this.columnNumber,
+        stack: this.stack,
+        // Axios
+        config: this.config,
+        code: this.code
+      };
+    };
+    return error;
+  };
+
+  /**
+   * Create an Error with the specified message, config, error code, request and response.
+   *
+   * @param {string} message The error message.
+   * @param {Object} config The config.
+   * @param {string} [code] The error code (for example, 'ECONNABORTED').
+   * @param {Object} [request] The request.
+   * @param {Object} [response] The response.
+   * @returns {Error} The created error.
+   */
+  var createError = function createError(message, config, code, request, response) {
+    var error = new Error(message);
+    return enhanceError(error, config, code, request, response);
+  };
+
+  /**
+   * Resolve or reject a Promise based on response status.
+   *
+   * @param {Function} resolve A function that resolves the promise.
+   * @param {Function} reject A function that rejects the promise.
+   * @param {object} response The response.
+   */
+  var settle = function settle(resolve, reject, response) {
+    var validateStatus = response.config.validateStatus;
+    if (!response.status || !validateStatus || validateStatus(response.status)) {
+      resolve(response);
+    } else {
+      reject(createError(
+        'Request failed with status code ' + response.status,
+        response.config,
+        null,
+        response.request,
+        response
+      ));
+    }
+  };
+
+  var cookies = (
+    utils.isStandardBrowserEnv() ?
+
+      // Standard browser envs support document.cookie
+      (function standardBrowserEnv() {
+        return {
+          write: function write(name, value, expires, path, domain, secure) {
+            var cookie = [];
+            cookie.push(name + '=' + encodeURIComponent(value));
+
+            if (utils.isNumber(expires)) {
+              cookie.push('expires=' + new Date(expires).toGMTString());
+            }
+
+            if (utils.isString(path)) {
+              cookie.push('path=' + path);
+            }
+
+            if (utils.isString(domain)) {
+              cookie.push('domain=' + domain);
+            }
+
+            if (secure === true) {
+              cookie.push('secure');
+            }
+
+            document.cookie = cookie.join('; ');
+          },
+
+          read: function read(name) {
+            var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+            return (match ? decodeURIComponent(match[3]) : null);
+          },
+
+          remove: function remove(name) {
+            this.write(name, '', Date.now() - 86400000);
+          }
+        };
+      })() :
+
+      // Non standard browser env (web workers, react-native) lack needed support.
+      (function nonStandardBrowserEnv() {
+        return {
+          write: function write() {
+          },
+          read: function read() {
+            return null;
+          },
+          remove: function remove() {
+          }
+        };
+      })()
+  );
+
+  /**
+   * Determines whether the specified URL is absolute
+   *
+   * @param {string} url The URL to test
+   * @returns {boolean} True if the specified URL is absolute, otherwise false
+   */
+  var isAbsoluteURL = function isAbsoluteURL(url) {
+    // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
+    // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
+    // by any combination of letters, digits, plus, period, or hyphen.
+    return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+  };
+
+  /**
+   * Creates a new URL by combining the specified URLs
+   *
+   * @param {string} baseURL The base URL
+   * @param {string} relativeURL The relative URL
+   * @returns {string} The combined URL
+   */
+  var combineURLs = function combineURLs(baseURL, relativeURL) {
+    return relativeURL
+      ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
+      : baseURL;
+  };
+
+  /**
+   * Creates a new URL by combining the baseURL with the requestedURL,
+   * only when the requestedURL is not already an absolute URL.
+   * If the requestURL is absolute, this function returns the requestedURL untouched.
+   *
+   * @param {string} baseURL The base URL
+   * @param {string} requestedURL Absolute or relative URL to combine
+   * @returns {string} The combined full path
+   */
+  var buildFullPath = function buildFullPath(baseURL, requestedURL) {
+    if (baseURL && !isAbsoluteURL(requestedURL)) {
+      return combineURLs(baseURL, requestedURL);
+    }
+    return requestedURL;
+  };
+
+  // Headers whose duplicates are ignored by node
+  // c.f. https://nodejs.org/api/http.html#http_message_headers
+  var ignoreDuplicateOf = [
+    'age', 'authorization', 'content-length', 'content-type', 'etag',
+    'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
+    'last-modified', 'location', 'max-forwards', 'proxy-authorization',
+    'referer', 'retry-after', 'user-agent'
+  ];
+
+  /**
+   * Parse headers into an object
+   *
+   * ```
+   * Date: Wed, 27 Aug 2014 08:58:49 GMT
+   * Content-Type: application/json
+   * Connection: keep-alive
+   * Transfer-Encoding: chunked
+   * ```
+   *
+   * @param {String} headers Headers needing to be parsed
+   * @returns {Object} Headers parsed into an object
+   */
+  var parseHeaders = function parseHeaders(headers) {
+    var parsed = {};
+    var key;
+    var val;
+    var i;
+
+    if (!headers) {
+      return parsed;
+    }
+
+    utils.forEach(headers.split('\n'), function parser(line) {
+      i = line.indexOf(':');
+      key = utils.trim(line.substr(0, i)).toLowerCase();
+      val = utils.trim(line.substr(i + 1));
+
+      if (key) {
+        if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
+          return;
+        }
+        if (key === 'set-cookie') {
+          parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+        } else {
+          parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+        }
+      }
+    });
+
+    return parsed;
+  };
+
+  var isURLSameOrigin = (
+    utils.isStandardBrowserEnv() ?
+
+      // Standard browser envs have full support of the APIs needed to test
+      // whether the request URL is of the same origin as current location.
+      (function standardBrowserEnv() {
+        var msie = /(msie|trident)/i.test(navigator.userAgent);
+        var urlParsingNode = document.createElement('a');
+        var originURL;
+
+        /**
+         * Parse a URL to discover it's components
+         *
+         * @param {String} url The URL to be parsed
+         * @returns {Object}
+         */
+        function resolveURL(url) {
+          var href = url;
+
+          if (msie) {
+            // IE needs attribute set twice to normalize properties
+            urlParsingNode.setAttribute('href', href);
+            href = urlParsingNode.href;
+          }
+
+          urlParsingNode.setAttribute('href', href);
+
+          // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
+          return {
+            href: urlParsingNode.href,
+            protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
+            host: urlParsingNode.host,
+            search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
+            hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
+            hostname: urlParsingNode.hostname,
+            port: urlParsingNode.port,
+            pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
+              urlParsingNode.pathname :
+              '/' + urlParsingNode.pathname
+          };
+        }
+
+        originURL = resolveURL(window.location.href);
+
+        /**
+         * Determine if a URL shares the same origin as the current location
+         *
+         * @param {String} requestURL The URL to test
+         * @returns {boolean} True if URL shares the same origin, otherwise false
+         */
+        return function isURLSameOrigin(requestURL) {
+          var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
+          return (parsed.protocol === originURL.protocol &&
+            parsed.host === originURL.host);
+        };
+      })() :
+
+      // Non standard browser envs (web workers, react-native) lack needed support.
+      (function nonStandardBrowserEnv() {
+        return function isURLSameOrigin() {
+          return true;
+        };
+      })()
+  );
+
+  var xhr = function xhrAdapter(config) {
+    return new Promise(function dispatchXhrRequest(resolve, reject) {
+      var requestData = config.data;
+      var requestHeaders = config.headers;
+
+      if (utils.isFormData(requestData)) {
+        delete requestHeaders['Content-Type']; // Let the browser set it
+      }
+
+      var request = new XMLHttpRequest();
+
+      // HTTP basic authentication
+      if (config.auth) {
+        var username = config.auth.username || '';
+        var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
+        requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
+      }
+
+      var fullPath = buildFullPath(config.baseURL, config.url);
+      request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
+
+      // Set the request timeout in MS
+      request.timeout = config.timeout;
+
+      // Listen for ready state
+      request.onreadystatechange = function handleLoad() {
+        if (!request || request.readyState !== 4) {
+          return;
+        }
+
+        // The request errored out and we didn't get a response, this will be
+        // handled by onerror instead
+        // With one exception: request that using file: protocol, most browsers
+        // will return status as 0 even though it's a successful request
+        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
+          return;
+        }
+
+        // Prepare the response
+        var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
+        var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
+        var response = {
+          data: responseData,
+          status: request.status,
+          statusText: request.statusText,
+          headers: responseHeaders,
+          config: config,
+          request: request
+        };
+
+        settle(resolve, reject, response);
+
+        // Clean up request
+        request = null;
+      };
+
+      // Handle browser request cancellation (as opposed to a manual cancellation)
+      request.onabort = function handleAbort() {
+        if (!request) {
+          return;
+        }
+
+        reject(createError('Request aborted', config, 'ECONNABORTED', request));
+
+        // Clean up request
+        request = null;
+      };
+
+      // Handle low level network errors
+      request.onerror = function handleError() {
+        // Real errors are hidden from us by the browser
+        // onerror should only fire if it's a network error
+        reject(createError('Network Error', config, null, request));
+
+        // Clean up request
+        request = null;
+      };
+
+      // Handle timeout
+      request.ontimeout = function handleTimeout() {
+        var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';
+        if (config.timeoutErrorMessage) {
+          timeoutErrorMessage = config.timeoutErrorMessage;
+        }
+        reject(createError(timeoutErrorMessage, config, 'ECONNABORTED',
+          request));
+
+        // Clean up request
+        request = null;
+      };
+
+      // Add xsrf header
+      // This is only done if running in a standard browser environment.
+      // Specifically not if we're in a web worker, or react-native.
+      if (utils.isStandardBrowserEnv()) {
+        // Add xsrf header
+        var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?
+          cookies.read(config.xsrfCookieName) :
+          undefined;
+
+        if (xsrfValue) {
+          requestHeaders[config.xsrfHeaderName] = xsrfValue;
+        }
+      }
+
+      // Add headers to the request
+      if ('setRequestHeader' in request) {
+        utils.forEach(requestHeaders, function setRequestHeader(val, key) {
+          if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
+            // Remove Content-Type if data is undefined
+            delete requestHeaders[key];
+          } else {
+            // Otherwise add header to the request
+            request.setRequestHeader(key, val);
+          }
+        });
+      }
+
+      // Add withCredentials to request if needed
+      if (!utils.isUndefined(config.withCredentials)) {
+        request.withCredentials = !!config.withCredentials;
+      }
+
+      // Add responseType to request if needed
+      if (config.responseType) {
+        try {
+          request.responseType = config.responseType;
+        } catch (e) {
+          // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.
+          // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.
+          if (config.responseType !== 'json') {
+            throw e;
+          }
+        }
+      }
+
+      // Handle progress if needed
+      if (typeof config.onDownloadProgress === 'function') {
+        request.addEventListener('progress', config.onDownloadProgress);
+      }
+
+      // Not all browsers support upload events
+      if (typeof config.onUploadProgress === 'function' && request.upload) {
+        request.upload.addEventListener('progress', config.onUploadProgress);
+      }
+
+      if (config.cancelToken) {
+        // Handle cancellation
+        config.cancelToken.promise.then(function onCanceled(cancel) {
+          if (!request) {
+            return;
+          }
+
+          request.abort();
+          reject(cancel);
+          // Clean up request
+          request = null;
+        });
+      }
+
+      if (!requestData) {
+        requestData = null;
+      }
+
+      // Send the request
+      request.send(requestData);
+    });
+  };
+
+  var DEFAULT_CONTENT_TYPE = {
+    'Content-Type': 'application/x-www-form-urlencoded'
+  };
+
+  function setContentTypeIfUnset(headers, value) {
+    if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
+      headers['Content-Type'] = value;
+    }
+  }
+
+  function getDefaultAdapter() {
+    var adapter;
+    if (typeof XMLHttpRequest !== 'undefined') {
+      // For browsers use XHR adapter
+      adapter = xhr;
+    } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
+      // For node use HTTP adapter
+      adapter = xhr;
+    }
+    return adapter;
+  }
+
+  var defaults = {
+    adapter: getDefaultAdapter(),
+
+    transformRequest: [function transformRequest(data, headers) {
+      normalizeHeaderName(headers, 'Accept');
+      normalizeHeaderName(headers, 'Content-Type');
+      if (utils.isFormData(data) ||
+        utils.isArrayBuffer(data) ||
+        utils.isBuffer(data) ||
+        utils.isStream(data) ||
+        utils.isFile(data) ||
+        utils.isBlob(data)
+      ) {
+        return data;
+      }
+      if (utils.isArrayBufferView(data)) {
+        return data.buffer;
+      }
+      if (utils.isURLSearchParams(data)) {
+        setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
+        return data.toString();
+      }
+      if (utils.isObject(data)) {
+        setContentTypeIfUnset(headers, 'application/json;charset=utf-8');
+        return JSON.stringify(data);
+      }
+      return data;
+    }],
+
+    transformResponse: [function transformResponse(data) {
+      /*eslint no-param-reassign:0*/
+      if (typeof data === 'string') {
+        try {
+          data = JSON.parse(data);
+        } catch (e) { /* Ignore */
+        }
+      }
+      return data;
+    }],
+
+    /**
+     * A timeout in milliseconds to abort a request. If set to 0 (default) a
+     * timeout is not created.
+     */
+    timeout: 0,
+
+    xsrfCookieName: 'XSRF-TOKEN',
+    xsrfHeaderName: 'X-XSRF-TOKEN',
+
+    maxContentLength: -1,
+    maxBodyLength: -1,
+
+    validateStatus: function validateStatus(status) {
+      return status >= 200 && status < 300;
+    }
+  };
+
+  defaults.headers = {
+    common: {
+      'Accept': 'application/json, text/plain, */*'
+    }
+  };
+
+  utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
+    defaults.headers[method] = {};
+  });
+
+  utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+    defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
+  });
+
+  var defaults_1 = defaults;
+
+  /**
+   * Throws a `Cancel` if cancellation has been requested.
+   */
+  function throwIfCancellationRequested(config) {
+    if (config.cancelToken) {
+      config.cancelToken.throwIfRequested();
+    }
+  }
+
+  /**
+   * Dispatch a request to the server using the configured adapter.
+   *
+   * @param {object} config The config that is to be used for the request
+   * @returns {Promise} The Promise to be fulfilled
+   */
+  var dispatchRequest = function dispatchRequest(config) {
+    throwIfCancellationRequested(config);
+
+    // Ensure headers exist
+    config.headers = config.headers || {};
+
+    // Transform request data
+    config.data = transformData(
+      config.data,
+      config.headers,
+      config.transformRequest
+    );
+
+    // Flatten headers
+    config.headers = utils.merge(
+      config.headers.common || {},
+      config.headers[config.method] || {},
+      config.headers
+    );
+
+    utils.forEach(
+      ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
+      function cleanHeaderConfig(method) {
+        delete config.headers[method];
+      }
+    );
+
+    var adapter = config.adapter || defaults_1.adapter;
+
+    return adapter(config).then(function onAdapterResolution(response) {
+      throwIfCancellationRequested(config);
+
+      // Transform response data
+      response.data = transformData(
+        response.data,
+        response.headers,
+        config.transformResponse
+      );
+
+      return response;
+    }, function onAdapterRejection(reason) {
+      if (!isCancel(reason)) {
+        throwIfCancellationRequested(config);
+
+        // Transform response data
+        if (reason && reason.response) {
+          reason.response.data = transformData(
+            reason.response.data,
+            reason.response.headers,
+            config.transformResponse
+          );
+        }
+      }
+
+      return Promise.reject(reason);
+    });
+  };
+
+  /**
+   * Config-specific merge-function which creates a new config-object
+   * by merging two configuration objects together.
+   *
+   * @param {Object} config1
+   * @param {Object} config2
+   * @returns {Object} New object resulting from merging config2 to config1
+   */
+  var mergeConfig = function mergeConfig(config1, config2) {
+    // eslint-disable-next-line no-param-reassign
+    config2 = config2 || {};
+    var config = {};
+
+    var valueFromConfig2Keys = ['url', 'method', 'data'];
+    var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy', 'params'];
+    var defaultToConfig2Keys = [
+      'baseURL', 'transformRequest', 'transformResponse', 'paramsSerializer',
+      'timeout', 'timeoutMessage', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName',
+      'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress', 'decompress',
+      'maxContentLength', 'maxBodyLength', 'maxRedirects', 'transport', 'httpAgent',
+      'httpsAgent', 'cancelToken', 'socketPath', 'responseEncoding'
+    ];
+    var directMergeKeys = ['validateStatus'];
+
+    function getMergedValue(target, source) {
+      if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
+        return utils.merge(target, source);
+      } else if (utils.isPlainObject(source)) {
+        return utils.merge({}, source);
+      } else if (utils.isArray(source)) {
+        return source.slice();
+      }
+      return source;
+    }
+
+    function mergeDeepProperties(prop) {
+      if (!utils.isUndefined(config2[prop])) {
+        config[prop] = getMergedValue(config1[prop], config2[prop]);
+      } else if (!utils.isUndefined(config1[prop])) {
+        config[prop] = getMergedValue(undefined, config1[prop]);
+      }
+    }
+
+    utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+      if (!utils.isUndefined(config2[prop])) {
+        config[prop] = getMergedValue(undefined, config2[prop]);
+      }
+    });
+
+    utils.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
+
+    utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+      if (!utils.isUndefined(config2[prop])) {
+        config[prop] = getMergedValue(undefined, config2[prop]);
+      } else if (!utils.isUndefined(config1[prop])) {
+        config[prop] = getMergedValue(undefined, config1[prop]);
+      }
+    });
+
+    utils.forEach(directMergeKeys, function merge(prop) {
+      if (prop in config2) {
+        config[prop] = getMergedValue(config1[prop], config2[prop]);
+      } else if (prop in config1) {
+        config[prop] = getMergedValue(undefined, config1[prop]);
+      }
+    });
+
+    var axiosKeys = valueFromConfig2Keys
+      .concat(mergeDeepPropertiesKeys)
+      .concat(defaultToConfig2Keys)
+      .concat(directMergeKeys);
+
+    var otherKeys = Object
+      .keys(config1)
+      .concat(Object.keys(config2))
+      .filter(function filterAxiosKeys(key) {
+        return axiosKeys.indexOf(key) === -1;
+      });
+
+    utils.forEach(otherKeys, mergeDeepProperties);
+
+    return config;
+  };
+
+  /**
+   * Create a new instance of Axios
+   *
+   * @param {Object} instanceConfig The default config for the instance
+   */
+  function Axios(instanceConfig) {
+    this.defaults = instanceConfig;
+    this.interceptors = {
+      request: new InterceptorManager_1(),
+      response: new InterceptorManager_1()
+    };
+  }
+
+  /**
+   * Dispatch a request
+   *
+   * @param {Object} config The config specific for this request (merged with this.defaults)
+   */
+  Axios.prototype.request = function request(config) {
+    /*eslint no-param-reassign:0*/
+    // Allow for axios('example/url'[, config]) a la fetch API
+    if (typeof config === 'string') {
+      config = arguments[1] || {};
+      config.url = arguments[0];
+    } else {
+      config = config || {};
+    }
+
+    config = mergeConfig(this.defaults, config);
+
+    // Set config.method
+    if (config.method) {
+      config.method = config.method.toLowerCase();
+    } else if (this.defaults.method) {
+      config.method = this.defaults.method.toLowerCase();
+    } else {
+      config.method = 'get';
+    }
+
+    // Hook up interceptors middleware
+    var chain = [dispatchRequest, undefined];
+    var promise = Promise.resolve(config);
+
+    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+      chain.unshift(interceptor.fulfilled, interceptor.rejected);
+    });
+
+    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+      chain.push(interceptor.fulfilled, interceptor.rejected);
+    });
+
+    while (chain.length) {
+      promise = promise.then(chain.shift(), chain.shift());
+    }
+
+    return promise;
+  };
+
+  Axios.prototype.getUri = function getUri(config) {
+    config = mergeConfig(this.defaults, config);
+    return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
+  };
+
+  // Provide aliases for supported request methods
+  utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
+    /*eslint func-names:0*/
+    Axios.prototype[method] = function (url, config) {
+      return this.request(mergeConfig(config || {}, {
+        method: method,
+        url: url,
+        data: (config || {}).data
+      }));
+    };
+  });
+
+  utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+    /*eslint func-names:0*/
+    Axios.prototype[method] = function (url, data, config) {
+      return this.request(mergeConfig(config || {}, {
+        method: method,
+        url: url,
+        data: data
+      }));
+    };
+  });
+
+  var Axios_1 = Axios;
+
+  /**
+   * A `Cancel` is an object that is thrown when an operation is canceled.
+   *
+   * @class
+   * @param {string=} message The message.
+   */
+  function Cancel(message) {
+    this.message = message;
+  }
+
+  Cancel.prototype.toString = function toString() {
+    return 'Cancel' + (this.message ? ': ' + this.message : '');
+  };
+
+  Cancel.prototype.__CANCEL__ = true;
+
+  var Cancel_1 = Cancel;
+
+  /**
+   * A `CancelToken` is an object that can be used to request cancellation of an operation.
+   *
+   * @class
+   * @param {Function} executor The executor function.
+   */
+  function CancelToken(executor) {
+    if (typeof executor !== 'function') {
+      throw new TypeError('executor must be a function.');
+    }
+
+    var resolvePromise;
+    this.promise = new Promise(function promiseExecutor(resolve) {
+      resolvePromise = resolve;
+    });
+
+    var token = this;
+    executor(function cancel(message) {
+      if (token.reason) {
+        // Cancellation has already been requested
+        return;
+      }
+
+      token.reason = new Cancel_1(message);
+      resolvePromise(token.reason);
+    });
+  }
+
+  /**
+   * Throws a `Cancel` if cancellation has been requested.
+   */
+  CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+    if (this.reason) {
+      throw this.reason;
+    }
+  };
+
+  /**
+   * Returns an object that contains a new `CancelToken` and a function that, when called,
+   * cancels the `CancelToken`.
+   */
+  CancelToken.source = function source() {
+    var cancel;
+    var token = new CancelToken(function executor(c) {
+      cancel = c;
+    });
+    return {
+      token: token,
+      cancel: cancel
+    };
+  };
+
+  var CancelToken_1 = CancelToken;
+
+  /**
+   * Syntactic sugar for invoking a function and expanding an array for arguments.
+   *
+   * Common use case would be to use `Function.prototype.apply`.
+   *
+   *  ```js
+   *  function f(x, y, z) {}
+   *  var args = [1, 2, 3];
+   *  f.apply(null, args);
+   *  ```
+   *
+   * With `spread` this example can be re-written.
+   *
+   *  ```js
+   *  spread(function(x, y, z) {})([1, 2, 3]);
+   *  ```
+   *
+   * @param {Function} callback
+   * @returns {Function}
+   */
+  var spread = function spread(callback) {
+    return function wrap(arr) {
+      return callback.apply(null, arr);
+    };
+  };
+
+  /**
+   * Determines whether the payload is an error thrown by Axios
+   *
+   * @param {*} payload The value to test
+   * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
+   */
+  var isAxiosError = function isAxiosError(payload) {
+    return (typeof payload === 'object') && (payload.isAxiosError === true);
+  };
+
+  /**
+   * Create an instance of Axios
+   *
+   * @param {Object} defaultConfig The default config for the instance
+   * @return {Axios} A new instance of Axios
+   */
+  function createInstance(defaultConfig) {
+    var context = new Axios_1(defaultConfig);
+    var instance = bind(Axios_1.prototype.request, context);
+
+    // Copy axios.prototype to instance
+    utils.extend(instance, Axios_1.prototype, context);
+
+    // Copy context to instance
+    utils.extend(instance, context);
+
+    return instance;
+  }
+
+  // Create the default instance to be exported
+  var axios$1 = createInstance(defaults_1);
+
+  // Expose Axios class to allow class inheritance
+  axios$1.Axios = Axios_1;
+
+  // Factory for creating new instances
+  axios$1.create = function create(instanceConfig) {
+    return createInstance(mergeConfig(axios$1.defaults, instanceConfig));
+  };
+
+  // Expose Cancel & CancelToken
+  axios$1.Cancel = Cancel_1;
+  axios$1.CancelToken = CancelToken_1;
+  axios$1.isCancel = isCancel;
+
+  // Expose all/spread
+  axios$1.all = function all(promises) {
+    return Promise.all(promises);
+  };
+  axios$1.spread = spread;
+
+  // Expose isAxiosError
+  axios$1.isAxiosError = isAxiosError;
+
+  var axios_1 = axios$1;
+
+  // Allow use of default import syntax in TypeScript
+  var _default = axios$1;
+  axios_1.default = _default;
+
+  var axios = axios_1;
+
+  class RTCEndpoint extends Event$1 {
+    constructor(options) {
+      super('RTCPusherPlayer');
+      this.TAG = '[RTCPusherPlayer]';
+      let defaults = {
+        element: '',
+        // html video element
+        debug: false,
+        // if output debug log
+        zlmsdpUrl: '',
+        simulcast: false,
+        useCamera: true,
+        audioEnable: true,
+        videoEnable: true,
+        recvOnly: false,
+        resolution: {
+          w: 0,
+          h: 0
+        },
+        usedatachannel: false
+      };
+      this.options = Object.assign({}, defaults, options);
+
+      if (this.options.debug) {
+        setLogger();
+      }
+
+      this.e = {
+        onicecandidate: this._onIceCandidate.bind(this),
+        ontrack: this._onTrack.bind(this),
+        onicecandidateerror: this._onIceCandidateError.bind(this),
+        onconnectionstatechange: this._onconnectionstatechange.bind(this),
+        ondatachannelopen: this._onDataChannelOpen.bind(this),
+        ondatachannelmsg: this._onDataChannelMsg.bind(this),
+        ondatachannelerr: this._onDataChannelErr.bind(this),
+        ondatachannelclose: this._onDataChannelClose.bind(this)
+      };
+      this._remoteStream = null;
+      this._localStream = null;
+      this.pc = new RTCPeerConnection(null);
+      this.pc.onicecandidate = this.e.onicecandidate;
+      this.pc.onicecandidateerror = this.e.onicecandidateerror;
+      this.pc.ontrack = this.e.ontrack;
+      this.pc.onconnectionstatechange = this.e.onconnectionstatechange;
+      this.datachannel = null;
+
+      if (this.options.usedatachannel) {
+        this.datachannel = this.pc.createDataChannel('chat');
+        this.datachannel.onclose = this.e.ondatachannelclose;
+        this.datachannel.onerror = this.e.ondatachannelerr;
+        this.datachannel.onmessage = this.e.ondatachannelmsg;
+        this.datachannel.onopen = this.e.ondatachannelopen;
+      }
+
+      if (!this.options.recvOnly && (this.options.audioEnable || this.options.videoEnable)) this.start(); else this.receive();
+    }
+
+    receive() {
+
+      const AudioTransceiverInit = {
+        direction: 'recvonly',
+        sendEncodings: []
+      };
+      const VideoTransceiverInit = {
+        direction: 'recvonly',
+        sendEncodings: []
+      };
+      this.pc.addTransceiver('audio', AudioTransceiverInit);
+      this.pc.addTransceiver('video', VideoTransceiverInit);
+      this.pc.createOffer().then(desc => {
+        log(this.TAG, 'offer:', desc.sdp);
+        this.pc.setLocalDescription(desc).then(() => {
+          axios({
+            method: 'post',
+            url: this.options.zlmsdpUrl,
+            responseType: 'json',
+            data: desc.sdp,
+            headers: {
+              'Content-Type': 'text/plain;charset=utf-8'
+            }
+          }).then(response => {
+            let ret = response.data; //JSON.parse(response.data);
+
+            if (ret.code != 0) {
+              // mean failed for offer/anwser exchange
+              this.dispatch(Events$1.WEBRTC_OFFER_ANWSER_EXCHANGE_FAILED, ret);
+              return;
+            }
+
+            let anwser = {};
+            anwser.sdp = ret.sdp;
+            anwser.type = 'answer';
+            log(this.TAG, 'answer:', ret.sdp);
+            this.pc.setRemoteDescription(anwser).then(() => {
+              log(this.TAG, 'set remote sucess');
+            }).catch(e => {
+              error(this.TAG, e);
+            });
+          });
+        });
+      }).catch(e => {
+        error(this.TAG, e);
+      });
+    }
+
+    start() {
+      let videoConstraints = false;
+      let audioConstraints = false;
+
+      if (this.options.useCamera) {
+        if (this.options.videoEnable) videoConstraints = new VideoTrackConstraints(VideoSourceInfo.CAMERA);
+        if (this.options.audioEnable) audioConstraints = new AudioTrackConstraints(AudioSourceInfo.MIC);
+      } else {
+        if (this.options.videoEnable) {
+          videoConstraints = new VideoTrackConstraints(VideoSourceInfo.SCREENCAST);
+          if (this.options.audioEnable) audioConstraints = new AudioTrackConstraints(AudioSourceInfo.SCREENCAST);
+        } else {
+          if (this.options.audioEnable) audioConstraints = new AudioTrackConstraints(AudioSourceInfo.MIC); else {
+            // error shared display media not only audio
+            error(this.TAG, 'error paramter');
+          }
+        }
+      }
+
+      if (this.options.resolution.w != 0 && this.options.resolution.h != 0 && typeof videoConstraints == 'object') {
+        videoConstraints.resolution = new Resolution(this.options.resolution.w, this.options.resolution.h);
+      }
+
+      MediaStreamFactory.createMediaStream(new StreamConstraints(audioConstraints, videoConstraints)).then(stream => {
+        this._localStream = stream;
+        this.dispatch(Events$1.WEBRTC_ON_LOCAL_STREAM, stream);
+        const AudioTransceiverInit = {
+          direction: 'sendrecv',
+          sendEncodings: []
+        };
+        const VideoTransceiverInit = {
+          direction: 'sendrecv',
+          sendEncodings: []
+        };
+
+        if (this.options.simulcast && stream.getVideoTracks().length > 0) {
+          VideoTransceiverInit.sendEncodings = [{
+            rid: 'h',
+            active: true,
+            maxBitrate: 1000000
+          }, {
+            rid: 'm',
+            active: true,
+            maxBitrate: 500000,
+            scaleResolutionDownBy: 2
+          }, {
+            rid: 'l',
+            active: true,
+            maxBitrate: 200000,
+            scaleResolutionDownBy: 4
+          }];
+        }
+
+        if (this.options.audioEnable) {
+          if (stream.getAudioTracks().length > 0) {
+            this.pc.addTransceiver(stream.getAudioTracks()[0], AudioTransceiverInit);
+          } else {
+            AudioTransceiverInit.direction = 'recvonly';
+            this.pc.addTransceiver('audio', AudioTransceiverInit);
+          }
+        }
+
+        if (this.options.videoEnable) {
+          if (stream.getVideoTracks().length > 0) {
+            this.pc.addTransceiver(stream.getVideoTracks()[0], VideoTransceiverInit);
+          } else {
+            VideoTransceiverInit.direction = 'recvonly';
+            this.pc.addTransceiver('video', VideoTransceiverInit);
+          }
+        }
+        /*
+	      stream.getTracks().forEach((track,idx)=>{
+	          debug.log(this.TAG,track);
+	          this.pc.addTrack(track);
+	      });
+	      */
+
+
+        this.pc.createOffer().then(desc => {
+          log(this.TAG, 'offer:', desc.sdp);
+          this.pc.setLocalDescription(desc).then(() => {
+            axios({
+              method: 'post',
+              url: this.options.zlmsdpUrl,
+              responseType: 'json',
+              data: desc.sdp,
+              headers: {
+                'Content-Type': 'text/plain;charset=utf-8'
+              }
+            }).then(response => {
+              let ret = response.data; //JSON.parse(response.data);
+
+              if (ret.code != 0) {
+                // mean failed for offer/anwser exchange
+                this.dispatch(Events$1.WEBRTC_OFFER_ANWSER_EXCHANGE_FAILED, ret);
+                return;
+              }
+
+              let anwser = {};
+              anwser.sdp = ret.sdp;
+              anwser.type = 'answer';
+              log(this.TAG, 'answer:', ret.sdp);
+              this.pc.setRemoteDescription(anwser).then(() => {
+                log(this.TAG, 'set remote sucess');
+              }).catch(e => {
+                error(this.TAG, e);
+              });
+            });
+          });
+        }).catch(e => {
+          error(this.TAG, e);
+        });
+      }).catch(e => {
+        this.dispatch(Events$1.CAPTURE_STREAM_FAILED); //debug.error(this.TAG,e);
+      }); //const offerOptions = {};
+
+      /*
+	    if (typeof this.pc.addTransceiver === 'function') {
+	        // |direction| seems not working on Safari.
+	        this.pc.addTransceiver('audio', { direction: 'recvonly' });
+	        this.pc.addTransceiver('video', { direction: 'recvonly' });
+	    } else {
+	        offerOptions.offerToReceiveAudio = true;
+	        offerOptions.offerToReceiveVideo = true;
+	    }
+	    */
+    }
+
+    _onIceCandidate(event) {
+      if (event.candidate) {
+        log('Remote ICE candidate: \n ' + event.candidate.candidate); // Send the candidate to the remote peer
+      }
+    }
+
+    _onTrack(event) {
+      if (this.options.element && event.streams && event.streams.length > 0) {
+        this.options.element.srcObject = event.streams[0];
+        this._remoteStream = event.streams[0];
+        this.dispatch(Events$1.WEBRTC_ON_REMOTE_STREAMS, event);
+      } else {
+        error('element pararm is failed');
+      }
+    }
+
+    _onIceCandidateError(event) {
+      this.dispatch(Events$1.WEBRTC_ICE_CANDIDATE_ERROR, event);
+    }
+
+    _onconnectionstatechange(event) {
+      this.dispatch(Events$1.WEBRTC_ON_CONNECTION_STATE_CHANGE, this.pc.connectionState);
+    }
+
+    _onDataChannelOpen(event) {
+      log(this.TAG, 'ondatachannel open:', event);
+      this.dispatch(Events$1.WEBRTC_ON_DATA_CHANNEL_OPEN, event);
+    }
+
+    _onDataChannelMsg(event) {
+      log(this.TAG, 'ondatachannel msg:', event);
+      this.dispatch(Events$1.WEBRTC_ON_DATA_CHANNEL_MSG, event);
+    }
+
+    _onDataChannelErr(event) {
+      log(this.TAG, 'ondatachannel err:', event);
+      this.dispatch(Events$1.WEBRTC_ON_DATA_CHANNEL_ERR, event);
+    }
+
+    _onDataChannelClose(event) {
+      log(this.TAG, 'ondatachannel close:', event);
+      this.dispatch(Events$1.WEBRTC_ON_DATA_CHANNEL_CLOSE, event);
+    }
+
+    sendMsg(data) {
+      if (this.datachannel != null) {
+        this.datachannel.send(data);
+      } else {
+        error(this.TAG, 'data channel is null');
+      }
+    }
+
+    closeDataChannel() {
+      if (this.datachannel) {
+        this.datachannel.close();
+        this.datachannel = null;
+      }
+    }
+
+    close() {
+      this.closeDataChannel();
+
+      if (this.pc) {
+        this.pc.close();
+        this.pc = null;
+      }
+
+      if (this.options) {
+        this.options = null;
+      }
+
+      if (this._localStream) {
+        this._localStream.getTracks().forEach((track, idx) => {
+          track.stop();
+        });
+      }
+
+      if (this._remoteStream) {
+        this._remoteStream.getTracks().forEach((track, idx) => {
+          track.stop();
+        });
+      }
+    }
+
+    get remoteStream() {
+      return this._remoteStream;
+    }
+
+    get localStream() {
+      return this._localStream;
+    }
+
+  }
+
+  const quickScan = [{
+    'label': '4K(UHD)',
+    'width': 3840,
+    'height': 2160
+  }, {
+    'label': '1080p(FHD)',
+    'width': 1920,
+    'height': 1080
+  }, {
+    'label': 'UXGA',
+    'width': 1600,
+    'height': 1200,
+    'ratio': '4:3'
+  }, {
+    'label': '720p(HD)',
+    'width': 1280,
+    'height': 720
+  }, {
+    'label': 'SVGA',
+    'width': 800,
+    'height': 600
+  }, {
+    'label': 'VGA',
+    'width': 640,
+    'height': 480
+  }, {
+    'label': '360p(nHD)',
+    'width': 640,
+    'height': 360
+  }, {
+    'label': 'CIF',
+    'width': 352,
+    'height': 288
+  }, {
+    'label': 'QVGA',
+    'width': 320,
+    'height': 240
+  }, {
+    'label': 'QCIF',
+    'width': 176,
+    'height': 144
+  }, {
+    'label': 'QQVGA',
+    'width': 160,
+    'height': 120
+  }];
+
+  function GetSupportCameraResolutions$1() {
+    return new Promise(function (resolve, reject) {
+      let resolutions = [];
+      let ok = 0;
+      let err = 0;
+
+      for (let i = 0; i < quickScan.length; ++i) {
+        let videoConstraints = new VideoTrackConstraints(VideoSourceInfo.CAMERA);
+        videoConstraints.resolution = new Resolution(quickScan[i].width, quickScan[i].height);
+        MediaStreamFactory.createMediaStream(new StreamConstraints(false, videoConstraints)).then(stream => {
+          resolutions.push(quickScan[i]);
+          ok++;
+
+          if (ok + err == quickScan.length) {
+            resolve(resolutions);
+          }
+        }).catch(e => {
+          err++;
+
+          if (ok + err == quickScan.length) {
+            resolve(resolutions);
+          }
+        });
+      }
+    });
+  }
+
+  function GetAllScanResolution$1() {
+    return quickScan;
+  }
+
+  function isSupportResolution$1(w, h) {
+    return new Promise(function (resolve, reject) {
+      let videoConstraints = new VideoTrackConstraints(VideoSourceInfo.CAMERA);
+      videoConstraints.resolution = new Resolution(w, h);
+      MediaStreamFactory.createMediaStream(new StreamConstraints(false, videoConstraints)).then(stream => {
+        resolve();
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+
+  console.log('build date:', BUILD_DATE);
+  console.log('version:', VERSION);
+  const Events = Events$1;
+  const Media = media;
+  const Endpoint = RTCEndpoint;
+  const GetSupportCameraResolutions = GetSupportCameraResolutions$1;
+  const GetAllScanResolution = GetAllScanResolution$1;
+  const isSupportResolution = isSupportResolution$1;
+
+  exports.Endpoint = Endpoint;
+  exports.RTCEndpoint = RTCEndpoint;
+  exports.Events = Events;
+  exports.GetAllScanResolution = GetAllScanResolution;
+  exports.GetSupportCameraResolutions = GetSupportCameraResolutions;
+  exports.Media = Media;
+  exports.isSupportResolution = isSupportResolution;
+
+  Object.defineProperty(exports, '__esModule', {value: true});
+
+  return exports;
+
+}({}));
+//# sourceMappingURL=ZLMRTCClient.js.map

ruoyi-ui/public/index.html

@@ -1,6 +1,6 @@
 <!DOCTYPE html>
 <html>
-  <head>
+<head>
     <meta charset="utf-8">
     <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
     <meta name="renderer" content="webkit">
@@ -9,202 +9,205 @@
     <title><%= webpackConfig.name %></title>
     <script src="<%= BASE_URL %>bdjs/jquery-2.2.4.min.js" crossorigin="anonymous"></script>
     <script type="text/javascript" src="<%= BASE_URL %>bdjs/BDLayers.js"></script>
-    <!--[if lt IE 11]><script>window.location.href='/html/ie.html';</script><![endif]-->
-	  <style>
-    html,
-    body,
-    #app {
-      height: 100%;
-      margin: 0px;
-      padding: 0px;
-    }
-    .chromeframe {
-      margin: 0.2em 0;
-      background: #ccc;
-      color: #000;
-      padding: 0.2em 0;
-    }
-
-    #loader-wrapper {
-      position: fixed;
-      top: 0;
-      left: 0;
-      width: 100%;
-      height: 100%;
-      z-index: 999999;
-    }
-
-    #loader {
-      display: block;
-      position: relative;
-      left: 50%;
-      top: 50%;
-      width: 150px;
-      height: 150px;
-      margin: -75px 0 0 -75px;
-      border-radius: 50%;
-      border: 3px solid transparent;
-      border-top-color: #FFF;
-      -webkit-animation: spin 2s linear infinite;
-      -ms-animation: spin 2s linear infinite;
-      -moz-animation: spin 2s linear infinite;
-      -o-animation: spin 2s linear infinite;
-      animation: spin 2s linear infinite;
-      z-index: 1001;
-    }
-
-    #loader:before {
-      content: "";
-      position: absolute;
-      top: 5px;
-      left: 5px;
-      right: 5px;
-      bottom: 5px;
-      border-radius: 50%;
-      border: 3px solid transparent;
-      border-top-color: #FFF;
-      -webkit-animation: spin 3s linear infinite;
-      -moz-animation: spin 3s linear infinite;
-      -o-animation: spin 3s linear infinite;
-      -ms-animation: spin 3s linear infinite;
-      animation: spin 3s linear infinite;
-    }
-
-    #loader:after {
-      content: "";
-      position: absolute;
-      top: 15px;
-      left: 15px;
-      right: 15px;
-      bottom: 15px;
-      border-radius: 50%;
-      border: 3px solid transparent;
-      border-top-color: #FFF;
-      -moz-animation: spin 1.5s linear infinite;
-      -o-animation: spin 1.5s linear infinite;
-      -ms-animation: spin 1.5s linear infinite;
-      -webkit-animation: spin 1.5s linear infinite;
-      animation: spin 1.5s linear infinite;
-    }
-
-
-    @-webkit-keyframes spin {
-      0% {
-        -webkit-transform: rotate(0deg);
-        -ms-transform: rotate(0deg);
-        transform: rotate(0deg);
-      }
-      100% {
-        -webkit-transform: rotate(360deg);
-        -ms-transform: rotate(360deg);
-        transform: rotate(360deg);
-      }
-    }
-
-    @keyframes spin {
-      0% {
-        -webkit-transform: rotate(0deg);
-        -ms-transform: rotate(0deg);
-        transform: rotate(0deg);
-      }
-      100% {
-        -webkit-transform: rotate(360deg);
-        -ms-transform: rotate(360deg);
-        transform: rotate(360deg);
-      }
-    }
-
-
-    #loader-wrapper .loader-section {
-      position: fixed;
-      top: 0;
-      width: 51%;
-      height: 100%;
-      background: #7171C6;
-      z-index: 1000;
-      -webkit-transform: translateX(0);
-      -ms-transform: translateX(0);
-      transform: translateX(0);
-    }
-
-    #loader-wrapper .loader-section.section-left {
-      left: 0;
-    }
-
-    #loader-wrapper .loader-section.section-right {
-      right: 0;
-    }
-
-
-    .loaded #loader-wrapper .loader-section.section-left {
-      -webkit-transform: translateX(-100%);
-      -ms-transform: translateX(-100%);
-      transform: translateX(-100%);
-      -webkit-transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
-      transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
-    }
-
-    .loaded #loader-wrapper .loader-section.section-right {
-      -webkit-transform: translateX(100%);
-      -ms-transform: translateX(100%);
-      transform: translateX(100%);
-      -webkit-transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
-      transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
-    }
-
-    .loaded #loader {
-      opacity: 0;
-      -webkit-transition: all 0.3s ease-out;
-      transition: all 0.3s ease-out;
-    }
-
-    .loaded #loader-wrapper {
-      visibility: hidden;
-      -webkit-transform: translateY(-100%);
-      -ms-transform: translateY(-100%);
-      transform: translateY(-100%);
-      -webkit-transition: all 0.3s 1s ease-out;
-      transition: all 0.3s 1s ease-out;
-    }
-
-    .no-js #loader-wrapper {
-      display: none;
-    }
-
-    .no-js h1 {
-      color: #222222;
-    }
-
-    #loader-wrapper .load_title {
-      font-family: 'Open Sans';
-      color: #FFF;
-      font-size: 19px;
-      width: 100%;
-      text-align: center;
-      z-index: 9999999999999;
-      position: absolute;
-      top: 60%;
-      opacity: 1;
-      line-height: 30px;
-    }
-
-    #loader-wrapper .load_title span {
-      font-weight: normal;
-      font-style: italic;
-      font-size: 13px;
-      color: #FFF;
-      opacity: 0.5;
-    }
-  </style>
-  </head>
-  <body>
-    <div id="app">
-	    <div id="loader-wrapper">
-		    <div id="loader"></div>
-		    <div class="loader-section section-left"></div>
-		    <div class="loader-section section-right"></div>
-		    <div class="load_title">正在加载系统资源，请耐心等待</div>
-        </div>
-	</div>
-  </body>
+    <script type="text/javascript" src="<%= BASE_URL %>ZLMRTCClient.js"></script>
+    <!--[if lt IE 11]>
+    <script>window.location.href = '/html/ie.html';</script><![endif]-->
+    <style>
+        html,
+        body,
+        #app {
+            height: 100%;
+            margin: 0px;
+            padding: 0px;
+        }
+
+        .chromeframe {
+            margin: 0.2em 0;
+            background: #ccc;
+            color: #000;
+            padding: 0.2em 0;
+        }
+
+        #loader-wrapper {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            z-index: 999999;
+        }
+
+        #loader {
+            display: block;
+            position: relative;
+            left: 50%;
+            top: 50%;
+            width: 150px;
+            height: 150px;
+            margin: -75px 0 0 -75px;
+            border-radius: 50%;
+            border: 3px solid transparent;
+            border-top-color: #FFF;
+            -webkit-animation: spin 2s linear infinite;
+            -ms-animation: spin 2s linear infinite;
+            -moz-animation: spin 2s linear infinite;
+            -o-animation: spin 2s linear infinite;
+            animation: spin 2s linear infinite;
+            z-index: 1001;
+        }
+
+        #loader:before {
+            content: "";
+            position: absolute;
+            top: 5px;
+            left: 5px;
+            right: 5px;
+            bottom: 5px;
+            border-radius: 50%;
+            border: 3px solid transparent;
+            border-top-color: #FFF;
+            -webkit-animation: spin 3s linear infinite;
+            -moz-animation: spin 3s linear infinite;
+            -o-animation: spin 3s linear infinite;
+            -ms-animation: spin 3s linear infinite;
+            animation: spin 3s linear infinite;
+        }
+
+        #loader:after {
+            content: "";
+            position: absolute;
+            top: 15px;
+            left: 15px;
+            right: 15px;
+            bottom: 15px;
+            border-radius: 50%;
+            border: 3px solid transparent;
+            border-top-color: #FFF;
+            -moz-animation: spin 1.5s linear infinite;
+            -o-animation: spin 1.5s linear infinite;
+            -ms-animation: spin 1.5s linear infinite;
+            -webkit-animation: spin 1.5s linear infinite;
+            animation: spin 1.5s linear infinite;
+        }
+
+
+        @-webkit-keyframes spin {
+            0% {
+                -webkit-transform: rotate(0deg);
+                -ms-transform: rotate(0deg);
+                transform: rotate(0deg);
+            }
+            100% {
+                -webkit-transform: rotate(360deg);
+                -ms-transform: rotate(360deg);
+                transform: rotate(360deg);
+            }
+        }
+
+        @keyframes spin {
+            0% {
+                -webkit-transform: rotate(0deg);
+                -ms-transform: rotate(0deg);
+                transform: rotate(0deg);
+            }
+            100% {
+                -webkit-transform: rotate(360deg);
+                -ms-transform: rotate(360deg);
+                transform: rotate(360deg);
+            }
+        }
+
+
+        #loader-wrapper .loader-section {
+            position: fixed;
+            top: 0;
+            width: 51%;
+            height: 100%;
+            background: #7171C6;
+            z-index: 1000;
+            -webkit-transform: translateX(0);
+            -ms-transform: translateX(0);
+            transform: translateX(0);
+        }
+
+        #loader-wrapper .loader-section.section-left {
+            left: 0;
+        }
+
+        #loader-wrapper .loader-section.section-right {
+            right: 0;
+        }
+
+
+        .loaded #loader-wrapper .loader-section.section-left {
+            -webkit-transform: translateX(-100%);
+            -ms-transform: translateX(-100%);
+            transform: translateX(-100%);
+            -webkit-transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
+            transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
+        }
+
+        .loaded #loader-wrapper .loader-section.section-right {
+            -webkit-transform: translateX(100%);
+            -ms-transform: translateX(100%);
+            transform: translateX(100%);
+            -webkit-transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
+            transition: all 0.7s 0.3s cubic-bezier(0.645, 0.045, 0.355, 1.000);
+        }
+
+        .loaded #loader {
+            opacity: 0;
+            -webkit-transition: all 0.3s ease-out;
+            transition: all 0.3s ease-out;
+        }
+
+        .loaded #loader-wrapper {
+            visibility: hidden;
+            -webkit-transform: translateY(-100%);
+            -ms-transform: translateY(-100%);
+            transform: translateY(-100%);
+            -webkit-transition: all 0.3s 1s ease-out;
+            transition: all 0.3s 1s ease-out;
+        }
+
+        .no-js #loader-wrapper {
+            display: none;
+        }
+
+        .no-js h1 {
+            color: #222222;
+        }
+
+        #loader-wrapper .load_title {
+            font-family: 'Open Sans';
+            color: #FFF;
+            font-size: 19px;
+            width: 100%;
+            text-align: center;
+            z-index: 9999999999999;
+            position: absolute;
+            top: 60%;
+            opacity: 1;
+            line-height: 30px;
+        }
+
+        #loader-wrapper .load_title span {
+            font-weight: normal;
+            font-style: italic;
+            font-size: 13px;
+            color: #FFF;
+            opacity: 0.5;
+        }
+    </style>
+</head>
+<body>
+<div id="app">
+    <div id="loader-wrapper">
+        <div id="loader"></div>
+        <div class="loader-section section-left"></div>
+        <div class="loader-section section-right"></div>
+        <div class="load_title">正在加载系统资源，请耐心等待</div>
+    </div>
+</div>
+</body>
 </html>

ruoyi-ui/src/api/bd/wvp.js

@@ -0,0 +1,319 @@
+import request from '@/utils/request'
+
+//分页获取国标设备列表
+export function deviceListpage(page, size) {
+  return request({
+    url: `/wvp/api/device/query/devices?page=${page}&size=${size}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//id查询国标设备
+export function device(deviceId) {
+  return request({
+    url: `/wvp/api/device/query/devices/${deviceId}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//添加/更新设备信息
+export function deviceAdd(device, type) {
+  return request({
+    url: `/wvp/api/device/query/device/${type}`,
+    method: 'post',
+    data: device,
+    async: false
+  })
+}
+
+//分页查询通道
+export function channels(deviceId, page, count, query, online, channelType, catalogUnderDevice) {
+  return request({
+    url: `/wvp/api/device/query/devices/${deviceId}/channels?page=${page}&count=${count}&query=${query}&online=${online}&channelType=${channelType}&catalogUnderDevice=${catalogUnderDevice}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//分页查询子目录通道
+export function subChannels(deviceId, channelId, page, count, query, online, channelType) {
+  return request({
+    url: `/wvp/api/device/query/sub_channels/${deviceId}/${channelId}/channels?page=${page}&count=${count}&query=${query}&online=${online}&channelType=${channelType}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//查询国标树
+export function getTree(deviceId, page, count, parentId, onlyCatalog) {
+  return request({
+    url: `/wvp/api/device/query/tree/${deviceId}?page=${page}&count=${count}&parentId=${parentId}&onlyCatalog=${onlyCatalog}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//移除设备
+export function deleteDevice(deviceId) {
+  return request({
+    url: `/wvp/api/device/query/devices/${deviceId}/delete`,
+    method: 'delete',
+    async: false
+  })
+}
+
+//同步设备通道
+export function devicesSync(deviceId) {
+  return request({
+    url: `/wvp/api/device/query/devices/${deviceId}/sync`,
+    method: 'get',
+    async: false
+  })
+}
+
+//获取通道同步进度
+export function getSyncStatus(deviceId) {
+  return request({
+    url: `/wvp/api/device/query/${deviceId}/sync_status`,
+    method: 'get',
+    async: false
+  })
+}
+
+//修改数据流传输模式
+export function updateTransport(deviceId, streamMode) {
+  return request({
+    url: `/wvp/api/device/query/transport/${deviceId}/${streamMode}`,
+    method: 'post',
+    async: false
+  })
+}
+
+//查询国标树下的通道
+export function getTreeChannel(deviceId, page, count, parentId) {
+  return request({
+    url: `/wvp/api/device/query/tree/channel/${deviceId}?page=${page}&count=${count}&parentId=${parentId}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//更新通道信息
+export function updateChannel(deviceId, data) {
+  return request({
+    url: `/wvp/api/device/query/channel/update/${deviceId}`,
+    data: data,
+    method: 'post',
+    async: false
+  })
+}
+
+//开始点播
+export function play(deviceId, channelId) {
+  return request({
+    url: `/wvp/api/play/start/${deviceId}/${channelId}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//停止点播
+export function stop(deviceId, channelId) {
+  return request({
+    url: `/wvp/api/play/stop/${deviceId}/${channelId}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//开始转码
+export function playConvert(streamId) {
+  return request({
+    url: `/wvp/api/play/convert/${streamId}`,
+    method: 'post',
+    async: false
+  })
+}
+
+//结束转码
+export function playConvertStop(key, mediaServerId) {
+  return request({
+    url: `/wvp/api/play/convertStop/${key}?mediaServerId=${mediaServerId}`,
+    method: 'post',
+    async: false
+  })
+}
+
+
+//编码信息
+export function getMediaInfo(mediaServerId, app, streamId) {
+  return request({
+    url: `/wvp/api/device/query/zlm/getMediaInfo/${mediaServerId}/${app}/${streamId}`,
+    method: 'get',
+    async: false
+  })
+}
+
+
+//媒体服务列表
+export function mediaServerList() {
+  return request({
+    url: `/wvp/api/server/media_server/list`,
+    method: 'get',
+    async: false
+  })
+}
+
+//在线流媒体服务列表
+export function getOnlineMediaServerList() {
+  return request({
+    url: `/wvp/api/server/media_server/online/list`,
+    method: 'get',
+    async: false
+  })
+}
+
+//在线流媒体服务列表
+export function getMediaServer(id) {
+  return request({
+    url: `/wvp/api/server/media_server/one/${id}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//测试流媒体服务
+export function checkMediaServer(ip, port, secret) {
+  return request({
+    url: `/wvp/api/server/media_server/check?ip=${ip}&port=${port}&secret=${secret}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//测试流媒体录像管理服务
+export function checkMediaRecordServer(ip, port) {
+  return request({
+    url: `/wvp/api/server/media_server/check?ip=${ip}&port=${port}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//保存流媒体服务
+export function saveMediaServer(data) {
+  return request({
+    url: `/wvp/api/server/media_server/save`,
+    data: data,
+    method: 'post',
+    async: false
+  })
+}
+
+//保存流媒体服务
+export function deleteMediaServer(id) {
+  return request({
+    url: `/wvp/api/server/media_server/delete?id=${id}`,
+    method: 'delete',
+    async: false
+  })
+}
+
+//云台控制
+export function ptz(deviceId, channelId, command, horizonSpeed, verticalSpeed, zoomSpeed) {
+  return request({
+    url: `/wvp/api/ptz/control/${deviceId}/${channelId}?command=${command}&horizonSpeed=${horizonSpeed}&verticalSpeed=${verticalSpeed}&zoomSpeed=${zoomSpeed}`,
+    method: 'post',
+    async: false
+  })
+}
+
+//通用前端控制命令
+export function frontEndCommand(deviceId, channelId, cmdCode, parameter1, parameter2, combindCode2) {
+  return request({
+    url: `/wvp/api/ptz/front_end_command/${deviceId}/${channelId}?cmdCode=${cmdCode}&parameter1=${parameter1}&parameter2=${parameter2}&combindCode2=${combindCode2}`,
+    method: 'post',
+    async: false
+  })
+}
+
+//获取系统信息信息
+export function getSysConfigInfo() {
+  return request({
+    url: `/wvp/api/server/system/configInfo`,
+    method: 'get',
+    async: false
+  })
+}
+
+//录像服务
+//分页获取app+stream的列表
+export function recordList(server,page,size) {
+  return request({
+    url: `/wvp/api/record/list?server=${server}&page=${page}&size=${size}`,
+    method: 'get',
+    async: false
+  })
+}
+
+//查询存在云端录像的日期
+export function cloudDateList(param) {
+  return request({
+    url: `/wvp/api/record/cloud/date/list`,
+    method: 'get',
+    params:param
+  })
+}
+
+//查询存在云端录像的日期
+export function cloudList(param) {
+  return request({
+    url: `/wvp/api/record/cloud/list`,
+    method: 'get',
+    params:param
+  })
+}
+//查询存在云端录像的日期
+export function getBaseHost() {
+  return request({
+    url: `/wvp/api/record/baseHost`,
+    method: 'get'
+  })
+}
+
+//开启录像
+export function startRecord(id) {
+  return request({
+    url: `/wvp/api/record/start/${id}`,
+    method: 'get'
+  })
+}
+//停止录像
+export function stopRecord(id) {
+  return request({
+    url: `/wvp/api/record/stop/${id}`,
+    method: 'get'
+  })
+}
+//发起对讲
+export function playBroadcast(deviceId,channelId,broadcastMode) {
+  return request({
+    url: `/wvp/api/play/broadcast/${deviceId}/${channelId}?timeout=30&broadcastMode=${broadcastMode}`,
+    method: 'get'
+  })
+}
+
+export function getPushKey() {
+  return request({
+    url: `/wvp/api/user/userInfo`,
+    method: 'post'
+  })
+}
+export function stopBroadcast(deviceId,channelId) {
+  return request({
+    url: `/wvp/api/play/broadcast/stop/${deviceId}/${channelId}`,
+    method: 'get'
+  })
+}

ruoyi-ui/src/directive/ws/WSHandle.js

@@ -0,0 +1,71 @@
+import SockJS from "sockjs-client";
+import Stomp from "stompjs";
+
+const prefix = process.env.VUE_APP_BASE_URL;
+export default {
+    data() {
+        return {
+            stompClient: null,
+        };
+    },
+    mounted() {
+    },
+    methods: {
+        init(url) {
+            let _that = this;
+            this.socket = new SockJS(`${prefix}${url}`);
+            let stompClient = Stomp.over(this.socket);
+            stompClient.connect({
+                login: 'admin',
+                passcode: '123456'
+            },  (frame)=> {
+                window.console.log(frame)
+                stompClient.subscribe('/user/topic', function (message) {
+                    window.console.warn(message);
+                    _that.cmes = message.body
+                    // window.console.log(JSON.parse(message.body));
+                });
+            })
+            this.stompClient = stompClient;
+        },
+        send(info) {
+            this.stompClient.send("/app/audio/stream", {
+                "camera": "application/json"
+            }, info)
+        },
+        startClient(topic) {
+            if (this.stompClient) {
+                this.stompClient.disconnect();
+                this.stompClient.destroyed();
+            }
+            let _that = this;
+            this.socket = new SockJS(`${prefix}${topic}`);
+            let stompClient = Stomp.over(this.socket);
+            this.stompClient = stompClient;
+            stompClient.connect({
+                login: 'admin',
+                passcode: '123456'
+            }, success => {
+                console.log(success)
+                // window.console.log(frame)
+                // stompClient.subscribe('/user/topic', function (message) {
+                //     window.console.warn(message);
+                //     _that.cmes = message.body
+                //     // window.console.log(JSON.parse(message.body));
+                // });
+            }, fail => {
+                console.log(fail)
+                _that.$message({
+                    type: 'error',
+                    message: fail,
+                });
+                this.stompClient.disconnect();
+            })
+
+        },
+    },
+    beforeDestroy() {
+        this.stompClient.destroyed();
+        this.stompClient = null;
+    },
+};

ruoyi-ui/src/utils/request.js

@@ -100,7 +100,7 @@ service.interceptors.response.use(res => {
     } else if (code === 601) {
       Message({ message: msg, type: 'warning' })
       return Promise.reject('error')
-    } else if (code !== 200) {
+    } else if (code !== 200 && code !== 200010) {
       Notification.error({ title: msg })
       return Promise.reject('error')
     } else {

ruoyi-ui/src/views/bd/VideoWall/index.vue

@@ -22,7 +22,6 @@
         <video-p v-for="item in videoList" :key="item.key"></video-p>
       </div>
     </div>
-    <socket-message :onMessage="onMessage" :ws="ws"></socket-message>
   </div>
 </template>
 
@@ -32,7 +31,10 @@ import VideoP from "@/components/video/index.vue";
 import IconRecording from "@/views/bd/VideoWall/icon/icon-recording.vue";
 import SocketMessage from "@/components/WebsocketMessage/index.vue";
 import IconUnrecord from "@/views/bd/VideoWall/icon/icon-unrecord.vue";
-import {Recorder} from "@/components/Audio/RecorderHandle";
+import crypto from 'crypto'
+import WSHandle from "@/directive/ws/WSHandle";
+import {playBroadcast} from "@/api/bd/wvp";
+
 
 const recordStatEnum = {
   recording: '录音中',
@@ -42,6 +44,7 @@ export default {
   name: "video-wall",
   components: {IconUnrecord, SocketMessage, IconRecording, VideoP},
   props: {},
+  mixins: [WSHandle],
   data() {
     return {
       recordStatEnum,
@@ -64,6 +67,7 @@ export default {
   computed: {},
   mounted() {
     VideoTraceDataManager.startCleanup();
+    this.startClient("/w-stomp")
   },
   methods: {
     onMessage(data) {
@@ -71,11 +75,93 @@ export default {
     },
     stopSpeaking(stat) {
       this.recordStat = stat;
+      this.broadcastRtc && this.broadcastRtc.close()
     },
-    startSpeaking(stat) {
-      this.recordStat = stat;
-      Recorder.start();
-    }
+    startSpeaking() {
+      playBroadcast("34020000001320000103", "34020000001370000266", true).then((res) => {
+        if (res.code === 200010) {
+          let streamInfo = res.data.streamInfo;
+          if (document.location.protocol.includes("https")) {
+            this.startBroadcast(streamInfo.rtcs)
+          } else {
+            this.startBroadcast(streamInfo.rtc)
+          }
+        } else {
+          this.$message({
+            showClose: true,
+            message: res.msg,
+            type: "error",
+          });
+        }
+      })
+
+    },
+    startBroadcast(url) {
+      const pushKey = '3e80d1762a324d5b0ff636e0bd16f1e3';
+      // 获取推流鉴权KEY
+      url = `${url}&sign=${crypto.createHash('md5').update(pushKey, "utf8").digest('hex')}`
+      console.log("开始语音喊话： " + url)
+      // eslint-disable-next-line no-undef
+      this.broadcastRtc = new ZLMRTCClient.Endpoint({
+        debug: true, // 是否打印日志
+        zlmsdpUrl: url, //流地址
+        simulecast: false,
+        useCamera: false,
+        audioEnable: true,
+        videoEnable: false,
+        recvOnly: false,
+      })
+      // eslint-disable-next-line no-undef
+      this.broadcastRtc.on(ZLMRTCClient.Events.WEBRTC_NOT_SUPPORT, (e) => {// 获取到了本地流
+        console.error('不支持webrtc', e)
+        this.$message({
+          showClose: true,
+          message: '不支持webrtc, 无法进行语音喊话',
+          type: 'error'
+        });
+        this.recordStat = recordStatEnum.recorded
+      });
+      // eslint-disable-next-line no-undef
+      this.broadcastRtc.on(ZLMRTCClient.Events.WEBRTC_ICE_CANDIDATE_ERROR, (e) => {// ICE 协商出错
+        console.error('ICE 协商出错')
+        this.$message({
+          showClose: true,
+          message: 'ICE 协商出错',
+          type: 'error'
+        });
+        this.recordStat = recordStatEnum.recorded
+      });
+      // eslint-disable-next-line no-undef
+      this.broadcastRtc.on(ZLMRTCClient.Events.WEBRTC_OFFER_ANWSER_EXCHANGE_FAILED, (e) => {// offer anwser 交换失败
+        console.error('offer anwser 交换失败', e)
+        this.$message({
+          showClose: true,
+          message: 'offer anwser 交换失败' + e,
+          type: 'error'
+        });
+        this.recordStat = recordStatEnum.recorded
+      });
+      // eslint-disable-next-line no-undef
+      this.broadcastRtc.on(ZLMRTCClient.Events.WEBRTC_ON_CONNECTION_STATE_CHANGE, (e) => {// offer anwser 交换失败
+        console.log('状态改变', e)
+        if (e === "connected") {
+          this.recordStat = recordStatEnum.recording
+        } else if (e === "disconnected") {
+          this.recordStat = recordStatEnum.recorded
+        }
+      });
+      // eslint-disable-next-line no-undef
+      this.broadcastRtc.on(ZLMRTCClient.Events.CAPTURE_STREAM_FAILED, (e) => {// offer anwser 交换失败
+        console.log('捕获流失败', e)
+        this.$message({
+          showClose: true,
+          message: '捕获流失败' + e,
+          type: 'error'
+        });
+        this.recordStat = recordStatEnum.recorded
+      });
+    },
+
   },
 };
 </script>

ruoyi-ui/src/views/bd/location/index.vue

@@ -126,8 +126,6 @@ export default {
   },
   methods: {
     init() {
-      debugger
-
       this.socket = new WebSocket(`ws://172.192.13.77:2223/socket/websocket/pollingArea`);
 
       this.socket.onopen = () => {

ruoyi-ui/src/views/bd/mobile/index.vue

@@ -53,7 +53,6 @@ export default {
         pageSize: 10,
       });
       this.evtList = rows;
-      debugger
     },
     async getFingerprint() {
       // 初始化FingerprintJS

ruoyi-ui/src/views/flow/definition/index.vue

@@ -266,7 +266,6 @@ export default {
     this.getList();
   },
   activated() {
-    debugger
     const time = this.$route.query.t;
     if (time != null && time != this.uniqueId) {
       this.uniqueId = time;

yarn.lock

@@ -0,0 +1,227 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@stomp/stompjs@^7.0.0":
+  version "7.0.0"
+  resolved "https://registry.npmmirror.com/@stomp/stompjs/-/stompjs-7.0.0.tgz#46b5c454a9dc8262e0b20f3b3dbacaa113993077"
+  integrity sha512-fGdq4wPDnSV/KyOsjq4P+zLc8MFWC3lMmP5FBgLWKPJTYcuCbAIrnRGjB7q2jHZdYCOD5vxLuFoKIYLy5/u8Pw==
+
+bufferutil@^4.0.1:
+  version "4.0.8"
+  resolved "https://registry.npmmirror.com/bufferutil/-/bufferutil-4.0.8.tgz#1de6a71092d65d7766c4d8a522b261a6e787e8ea"
+  integrity sha512-4T53u4PdgsXqKaIctwF8ifXlRTTmEPJ8iEPWFdGZvcf7sbwYo6FKFEX9eNNAnzFZ7EzJAQ3CJeOtCRA4rDp7Pw==
+  dependencies:
+    node-gyp-build "^4.3.0"
+
+d@1, d@^1.0.1, d@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.npmmirror.com/d/-/d-1.0.2.tgz#2aefd554b81981e7dccf72d6842ae725cb17e5de"
+  integrity sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==
+  dependencies:
+    es5-ext "^0.10.64"
+    type "^2.7.2"
+
+debug@^2.2.0:
+  version "2.6.9"
+  resolved "https://registry.npmmirror.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
+  integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
+  dependencies:
+    ms "2.0.0"
+
+debug@^3.2.7:
+  version "3.2.7"
+  resolved "https://registry.npmmirror.com/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a"
+  integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
+  dependencies:
+    ms "^2.1.1"
+
+es5-ext@^0.10.35, es5-ext@^0.10.62, es5-ext@^0.10.63, es5-ext@^0.10.64, es5-ext@~0.10.14:
+  version "0.10.64"
+  resolved "https://registry.npmmirror.com/es5-ext/-/es5-ext-0.10.64.tgz#12e4ffb48f1ba2ea777f1fcdd1918ef73ea21714"
+  integrity sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==
+  dependencies:
+    es6-iterator "^2.0.3"
+    es6-symbol "^3.1.3"
+    esniff "^2.0.1"
+    next-tick "^1.1.0"
+
+es6-iterator@^2.0.3:
+  version "2.0.3"
+  resolved "https://registry.npmmirror.com/es6-iterator/-/es6-iterator-2.0.3.tgz#a7de889141a05a94b0854403b2d0a0fbfa98f3b7"
+  integrity sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==
+  dependencies:
+    d "1"
+    es5-ext "^0.10.35"
+    es6-symbol "^3.1.1"
+
+es6-symbol@^3.1.1, es6-symbol@^3.1.3:
+  version "3.1.4"
+  resolved "https://registry.npmmirror.com/es6-symbol/-/es6-symbol-3.1.4.tgz#f4e7d28013770b4208ecbf3e0bf14d3bcb557b8c"
+  integrity sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==
+  dependencies:
+    d "^1.0.2"
+    ext "^1.7.0"
+
+esniff@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.npmmirror.com/esniff/-/esniff-2.0.1.tgz#a4d4b43a5c71c7ec51c51098c1d8a29081f9b308"
+  integrity sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==
+  dependencies:
+    d "^1.0.1"
+    es5-ext "^0.10.62"
+    event-emitter "^0.3.5"
+    type "^2.7.2"
+
+event-emitter@^0.3.5:
+  version "0.3.5"
+  resolved "https://registry.npmmirror.com/event-emitter/-/event-emitter-0.3.5.tgz#df8c69eef1647923c7157b9ce83840610b02cc39"
+  integrity sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==
+  dependencies:
+    d "1"
+    es5-ext "~0.10.14"
+
+eventsource@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.npmmirror.com/eventsource/-/eventsource-2.0.2.tgz#76dfcc02930fb2ff339520b6d290da573a9e8508"
+  integrity sha512-IzUmBGPR3+oUG9dUeXynyNmf91/3zUSJg1lCktzKw47OXuhco54U3r9B7O4XX+Rb1Itm9OZ2b0RkTs10bICOxA==
+
+ext@^1.7.0:
+  version "1.7.0"
+  resolved "https://registry.npmmirror.com/ext/-/ext-1.7.0.tgz#0ea4383c0103d60e70be99e9a7f11027a33c4f5f"
+  integrity sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==
+  dependencies:
+    type "^2.7.2"
+
+faye-websocket@^0.11.4:
+  version "0.11.4"
+  resolved "https://registry.npmmirror.com/faye-websocket/-/faye-websocket-0.11.4.tgz#7f0d9275cfdd86a1c963dc8b65fcc451edcbb1da"
+  integrity sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==
+  dependencies:
+    websocket-driver ">=0.5.1"
+
+http-parser-js@>=0.5.1:
+  version "0.5.8"
+  resolved "https://registry.npmmirror.com/http-parser-js/-/http-parser-js-0.5.8.tgz#af23090d9ac4e24573de6f6aecc9d84a48bf20e3"
+  integrity sha512-SGeBX54F94Wgu5RH3X5jsDtf4eHyRogWX1XGT3b4HuW3tQPM4AaBzoUji/4AAJNXCEOWZ5O0DgZmJw1947gD5Q==
+
+inherits@^2.0.4:
+  version "2.0.4"
+  resolved "https://registry.npmmirror.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
+  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
+
+is-typedarray@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmmirror.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
+  integrity sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==
+
+ms@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmmirror.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
+  integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==
+
+ms@^2.1.1:
+  version "2.1.3"
+  resolved "https://registry.npmmirror.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
+  integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
+
+next-tick@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmmirror.com/next-tick/-/next-tick-1.1.0.tgz#1836ee30ad56d67ef281b22bd199f709449b35eb"
+  integrity sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==
+
+node-gyp-build@^4.3.0:
+  version "4.8.3"
+  resolved "https://registry.npmmirror.com/node-gyp-build/-/node-gyp-build-4.8.3.tgz#9187216d24dbee29e44eb20d2ebf62a296bbea1a"
+  integrity sha512-EMS95CMJzdoSKoIiXo8pxKoL8DYxwIZXYlLmgPb8KUv794abpnLK6ynsCAWNliOjREKruYKdzbh76HHYUHX7nw==
+
+querystringify@^2.1.1:
+  version "2.2.0"
+  resolved "https://registry.npmmirror.com/querystringify/-/querystringify-2.2.0.tgz#3345941b4153cb9d082d8eee4cda2016a9aef7f6"
+  integrity sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==
+
+requires-port@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmmirror.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff"
+  integrity sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==
+
+safe-buffer@>=5.1.0:
+  version "5.2.1"
+  resolved "https://registry.npmmirror.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
+  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
+
+sockjs-client@^1.6.1:
+  version "1.6.1"
+  resolved "https://registry.npmmirror.com/sockjs-client/-/sockjs-client-1.6.1.tgz#350b8eda42d6d52ddc030c39943364c11dcad806"
+  integrity sha512-2g0tjOR+fRs0amxENLi/q5TiJTqY+WXFOzb5UwXndlK6TO3U/mirZznpx6w34HVMoc3g7cY24yC/ZMIYnDlfkw==
+  dependencies:
+    debug "^3.2.7"
+    eventsource "^2.0.2"
+    faye-websocket "^0.11.4"
+    inherits "^2.0.4"
+    url-parse "^1.5.10"
+
+stompjs@^2.3.3:
+  version "2.3.3"
+  resolved "https://registry.npmmirror.com/stompjs/-/stompjs-2.3.3.tgz#34178ac7bb8ee294cc5d554ad8b50f7f5459fd8e"
+  integrity sha512-5l/Ogz0DTFW7TrpHF0LAETGqM/so8UxNJvYZjJKqcX31EVprSQgnGkO80tZctPC/lFBDUrSFiTG3xd0R27XAIA==
+  optionalDependencies:
+    websocket latest
+
+type@^2.7.2:
+  version "2.7.3"
+  resolved "https://registry.npmmirror.com/type/-/type-2.7.3.tgz#436981652129285cc3ba94f392886c2637ea0486"
+  integrity sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==
+
+typedarray-to-buffer@^3.1.5:
+  version "3.1.5"
+  resolved "https://registry.npmmirror.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz#a97ee7a9ff42691b9f783ff1bc5112fe3fca9080"
+  integrity sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==
+  dependencies:
+    is-typedarray "^1.0.0"
+
+url-parse@^1.5.10:
+  version "1.5.10"
+  resolved "https://registry.npmmirror.com/url-parse/-/url-parse-1.5.10.tgz#9d3c2f736c1d75dd3bd2be507dcc111f1e2ea9c1"
+  integrity sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==
+  dependencies:
+    querystringify "^2.1.1"
+    requires-port "^1.0.0"
+
+utf-8-validate@^5.0.2:
+  version "5.0.10"
+  resolved "https://registry.npmmirror.com/utf-8-validate/-/utf-8-validate-5.0.10.tgz#d7d10ea39318171ca982718b6b96a8d2442571a2"
+  integrity sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==
+  dependencies:
+    node-gyp-build "^4.3.0"
+
+websocket-driver@>=0.5.1:
+  version "0.7.4"
+  resolved "https://registry.npmmirror.com/websocket-driver/-/websocket-driver-0.7.4.tgz#89ad5295bbf64b480abcba31e4953aca706f5760"
+  integrity sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==
+  dependencies:
+    http-parser-js ">=0.5.1"
+    safe-buffer ">=5.1.0"
+    websocket-extensions ">=0.1.1"
+
+websocket-extensions@>=0.1.1:
+  version "0.1.4"
+  resolved "https://registry.npmmirror.com/websocket-extensions/-/websocket-extensions-0.1.4.tgz#7f8473bc839dfd87608adb95d7eb075211578a42"
+  integrity sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==
+
+websocket@latest:
+  version "1.0.35"
+  resolved "https://registry.npmmirror.com/websocket/-/websocket-1.0.35.tgz#374197207d7d4cc4c36cbf8a1bb886ee52a07885"
+  integrity sha512-/REy6amwPZl44DDzvRCkaI1q1bIiQB0mEFQLUrhz3z2EK91cp3n72rAjUlrTP0zV22HJIUOVHQGPxhFRjxjt+Q==
+  dependencies:
+    bufferutil "^4.0.1"
+    debug "^2.2.0"
+    es5-ext "^0.10.63"
+    typedarray-to-buffer "^3.1.5"
+    utf-8-validate "^5.0.2"
+    yaeti "^0.0.6"
+
+yaeti@^0.0.6:
+  version "0.0.6"
+  resolved "https://registry.npmmirror.com/yaeti/-/yaeti-0.0.6.tgz#f26f484d72684cf42bedfb76970aa1608fbf9577"
+  integrity sha512-MvQa//+KcZCUkBTIC9blM+CU9J2GzuTytsOUwf2lidtvkx/6gnEp1QvJv34t9vdjhFmha/mUiNDbN0D0mJWdug==