Android基于腾讯云实时音视频仿微信视频通话最小化悬浮

2023-08-08 18:43:05 88

最近项目中有需要语音、视频通话需求，看到这个像环信、融云等SDK都有具体Demo实现，但咋的领导对腾讯情有独钟啊，IM要用腾讯云IM，不妙的是腾讯云IM并不包含有音视频通话都要自己实现，没办法深入了解腾讯云产品后，决定自己基于腾讯云实时音视频做去语音、视频通话功能。在这里把实现过程记录下为以后用到便于查阅，另一方面也给有需要的人提供一个思路，让大家少走弯路，有可能我的实现的方法不是最好，但是这或许是一个可行的方案，大家不喜勿喷。基于腾讯云实时音视频SDK 6.5.7272版本，腾讯DEMO下载地址：链接:https://pan.baidu.com/s/1iJsVO3KBuhEiIUZcJPyv3g提取码:ueey

一、实现效果

二、实现思路

我把实现思路拆分为了两步：1、视频通话Activity的最小化。2、视频通话悬浮框的开启

具体思路是这样的：当用户点击左上角最小化按钮的时候，最小化视频通话Activity（这时Activity处于后台状态），于此同时开启悬浮框，新建一个新的ViewGroup将全局Constents.mVideoViewLayout中用户选中的最大View动态添加到悬浮框里面去，监听悬浮框的触摸事件，让悬浮框可以拖拽移动；自定义点击事件，如果用户点击了悬浮框，则移除悬浮框然后重新调起我们在后台的视频通话Activity。

1.Activity是如何实现最小化的？

Activity本身自带了一个moveTaskToBack(booleannonRoot)，我们要实现最小化只需要调用moveTaskToBack(true)传入一个true值就可以了，但是这里有一个前提，就是需要设置Activity的启动模式为singleInstance模式，两步搞定。（注：activity最小化后重新从后台回到前台会回调onRestart()方法）

@Override
publicbooleanmoveTaskToBack(booleannonRoot){
returnsuper.moveTaskToBack(nonRoot);
}

2.悬浮框是如何开启的？

悬浮框的实现方法最好写在Service里面，将悬浮框的开启关闭与服务Service的绑定解绑所关联起来，开启服务即相当于开启我们的悬浮框，解绑服务则相当于关闭关闭的悬浮框，以此来达到更好的控制效果。

a.首先我们声明一个服务类，取名为FloatVideoWindowService：

publicclassFloatVideoWindowServiceextendsService{

@Nullable
@Override
publicIBinderonBind(Intentintent){
returnnewMyBinder();
}

publicclassMyBinderextendsBinder{
publicFloatVideoWindowServicegetService(){
returnFloatVideoWindowService.this;
}
}

@Override
publicvoidonCreate(){
super.onCreate();
}

@Override
publicintonStartCommand(Intentintent,intflags,intstartId){
returnsuper.onStartCommand(intent,flags,startId);
}

@Override
publicvoidonDestroy(){
super.onDestroy();
}
}

b.为悬浮框建立一个布局文件float_video_window_layout，悬浮框大小我这里固定为长80dp，高120dp，id为small_size_preview的RelativeLayout主要是一个容器，可以动态的添加view到里面去

c.布局定义好后，接下来就要对悬浮框做一些初始化操作了，初始化操作这里我们放在服务的onCreate()生命周期里面执行，因为只需要执行一次就行了。这里的初始化主要包括对：悬浮框的基本参数（位置，宽高等），悬浮框的点击事件以及悬浮框的触摸事件（即可拖动范围）等的设置，在onBind()中从Intent中取出了Activity中用户选中最大View的id，以便在后面从 Constents.mVideoViewLayout中取出对应View，然后加入悬浮窗布局中

/**
*视频悬浮窗服务
*/
publicclassFloatVideoWindowServiceextendsService{
privateWindowManagermWindowManager;
privateWindowManager.LayoutParamswmParams;
privateLayoutInflaterinflater;
privateStringcurrentBigUserId;
//浮动布局view
privateViewmFloatingLayout;
//容器父布局
privateRelativeLayoutsmallSizePreviewLayout;
privateTXCloudVideoViewmLocalVideoView;


@Override
publicvoidonCreate(){
super.onCreate();
initWindow();//设置悬浮窗基本参数（位置、宽高等）

}

@Nullable
@Override
publicIBinderonBind(Intentintent){
currentBigUserId=intent.getStringExtra("userId");
initFloating();//悬浮框点击事件的处理
returnnewMyBinder();
}

publicclassMyBinderextendsBinder{
publicFloatVideoWindowServicegetService(){
returnFloatVideoWindowService.this;
}
}


@Override
publicintonStartCommand(Intentintent,intflags,intstartId){
returnsuper.onStartCommand(intent,flags,startId);
}


/**
*设置悬浮框基本参数（位置、宽高等）
*/
privatevoidinitWindow(){
mWindowManager=(WindowManager)getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
//设置好悬浮窗的参数
wmParams=getParams();
//悬浮窗默认显示以左上角为起始坐标
wmParams.gravity=Gravity.LEFT|Gravity.TOP;
//悬浮窗的开始位置，因为设置的是从左上角开始，所以屏幕左上角是x=0;y=0
wmParams.x=70;
wmParams.y=210;
//得到容器，通过这个inflater来获得悬浮窗控件
inflater=LayoutInflater.from(getApplicationContext());
//获取浮动窗口视图所在布局
mFloatingLayout=inflater.inflate(R.layout.alert_float_video_layout,null);
//添加悬浮窗的视图
mWindowManager.addView(mFloatingLayout,wmParams);
}


privateWindowManager.LayoutParamsgetParams(){
wmParams=newWindowManager.LayoutParams();
if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.O){
wmParams.type=WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
}else{
wmParams.type=WindowManager.LayoutParams.TYPE_PHONE;
}
//设置可以显示在状态栏上
wmParams.flags=WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL|
WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN|WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR|
WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;

//设置悬浮窗口长宽数据
wmParams.width=WindowManager.LayoutParams.WRAP_CONTENT;
wmParams.height=WindowManager.LayoutParams.WRAP_CONTENT;
returnwmParams;
}

privatevoidinitFloating(){


}
}

d.在悬浮框成功被初始化以及相关参数被设置后，接下来就需要将Activity中用户选中最大的View添加到悬浮框里面去了，这样我们才能看到视频画面嘛，同样我们是在Service的onCreate这个生命周期中initFloating()完成这个操作的，代码如下所示：

TRTCVideoViewLayoutmTRTCVideoViewLayout=Constents.mVideoViewLayout;
TXCloudVideoViewmLocalVideoView=mTRTCVideoViewLayout.getCloudVideoViewByUseId(currentBigUserId);
if(mLocalVideoView==null){
mLocalVideoView=mTRTCVideoViewLayout.getCloudVideoViewByIndex(0);
}
if(ConstData.userid.equals(currentBigUserId)){
TXCGLSurfaceViewmTXCGLSurfaceView=mLocalVideoView.getGLSurfaceView();
if(mTXCGLSurfaceView!=null&&mTXCGLSurfaceView.getParent()!=null){
((ViewGroup)mTXCGLSurfaceView.getParent()).removeView(mTXCGLSurfaceView);
mTXCloudVideoView.addVideoView(mTXCGLSurfaceView);
}
}else{
TextureViewmTextureView=mLocalVideoView.getVideoView();
if(mTextureView!=null&&mTextureView.getParent()!=null){
((ViewGroup)mTextureView.getParent()).removeView(mTextureView);
mTXCloudVideoView.addVideoView(mTextureView);
}
}

e.我们上面说到要将服务Service的绑定与解绑与悬浮框的开启和关闭相结合，所以既然我们在服务的onCreate()方法中开启了悬浮框，那么就应该在其onDestroy()方法中对悬浮框进行关闭，关闭悬浮框的本质是将相关View给移除掉，在服务的onDestroy()方法中执行如下代码：

@Override
publicvoidonDestroy(){
super.onDestroy();
if(mFloatingLayout!=null){
//移除悬浮窗口
mWindowManager.removeView(mFloatingLayout);
mFloatingLayout=null;
Constents.isShowFloatWindow=false;
}
}

f.服务的绑定方式有bindService和startService两种，使用不同的绑定方式其生命周期也会不一样，已知我们需要让悬浮框在视频通话activityfinish掉的时候也顺便关掉，那么理所当然我们就应该采用bind方式来启动服务，让他的生命周期跟随他的开启者，也即是跟随开启它的activity生命周期。

intent=newIntent(this,FloatVideoWindowService.class);//开启服务显示悬浮框
bindService(intent,mVideoServiceConnection,Context.BIND_AUTO_CREATE);

ServiceConnectionmVideoServiceConnection=newServiceConnection(){

@Override
publicvoidonServiceConnected(ComponentNamename,IBinderservice){
//获取服务的操作对象
FloatVideoWindowService.MyBinderbinder=(FloatVideoWindowService.MyBinder)service;
binder.getService();
}

@Override
publicvoidonServiceDisconnected(ComponentNamename){
}
};

Service完整代码如下：

/**
*视频悬浮窗服务
*/
publicclassFloatVideoWindowServiceextendsService{
privateWindowManagermWindowManager;
privateWindowManager.LayoutParamswmParams;
privateLayoutInflaterinflater;
privateStringcurrentBigUserId;
//浮动布局view
privateViewmFloatingLayout;
//容器父布局
privateTXCloudVideoViewmTXCloudVideoView;


@Override
publicvoidonCreate(){
super.onCreate();
initWindow();//设置悬浮窗基本参数（位置、宽高等）

}

@Nullable
@Override
publicIBinderonBind(Intentintent){
currentBigUserId=intent.getStringExtra("userId");
initFloating();//悬浮框点击事件的处理
returnnewMyBinder();
}

publicclassMyBinderextendsBinder{
publicFloatVideoWindowServicegetService(){
returnFloatVideoWindowService.this;
}
}


@Override
publicintonStartCommand(Intentintent,intflags,intstartId){
returnsuper.onStartCommand(intent,flags,startId);
}

@Override
publicvoidonDestroy(){
super.onDestroy();
if(mFloatingLayout!=null){
//移除悬浮窗口
mWindowManager.removeView(mFloatingLayout);
mFloatingLayout=null;
Constents.isShowFloatWindow=false;
}
}

/**
*设置悬浮框基本参数（位置、宽高等）
*/
privatevoidinitWindow(){
mWindowManager=(WindowManager)getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
//设置好悬浮窗的参数
wmParams=getParams();
//悬浮窗默认显示以左上角为起始坐标
wmParams.gravity=Gravity.LEFT|Gravity.TOP;
//悬浮窗的开始位置，因为设置的是从左上角开始，所以屏幕左上角是x=0;y=0
wmParams.x=70;
wmParams.y=210;
//得到容器，通过这个inflater来获得悬浮窗控件
inflater=LayoutInflater.from(getApplicationContext());
//获取浮动窗口视图所在布局
mFloatingLayout=inflater.inflate(R.layout.alert_float_video_layout,null);
//添加悬浮窗的视图
mWindowManager.addView(mFloatingLayout,wmParams);
}


privateWindowManager.LayoutParamsgetParams(){
wmParams=newWindowManager.LayoutParams();
if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.O){
wmParams.type=WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
}else{
wmParams.type=WindowManager.LayoutParams.TYPE_PHONE;
}
//设置可以显示在状态栏上
wmParams.flags=WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL|
WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN|WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR|
WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;

//设置悬浮窗口长宽数据
wmParams.width=WindowManager.LayoutParams.WRAP_CONTENT;
wmParams.height=WindowManager.LayoutParams.WRAP_CONTENT;
returnwmParams;
}

privatevoidinitFloating(){
mTXCloudVideoView=mFloatingLayout.findViewById(R.id.float_videoview);
TRTCVideoViewLayoutmTRTCVideoViewLayout=Constents.mVideoViewLayout;
TXCloudVideoViewmLocalVideoView=mTRTCVideoViewLayout.getCloudVideoViewByUseId(currentBigUserId);
if(mLocalVideoView==null){
mLocalVideoView=mTRTCVideoViewLayout.getCloudVideoViewByIndex(0);
}
if(ConstData.userid.equals(currentBigUserId)){
TXCGLSurfaceViewmTXCGLSurfaceView=mLocalVideoView.getGLSurfaceView();
if(mTXCGLSurfaceView!=null&&mTXCGLSurfaceView.getParent()!=null){
((ViewGroup)mTXCGLSurfaceView.getParent()).removeView(mTXCGLSurfaceView);
mTXCloudVideoView.addVideoView(mTXCGLSurfaceView);
}
}else{
TextureViewmTextureView=mLocalVideoView.getVideoView();
if(mTextureView!=null&&mTextureView.getParent()!=null){
((ViewGroup)mTextureView.getParent()).removeView(mTextureView);
mTXCloudVideoView.addVideoView(mTextureView);
}
}
Constents.isShowFloatWindow=true;
//悬浮框触摸事件，设置悬浮框可拖动
mTXCloudVideoView.setOnTouchListener(newFloatingListener());
//悬浮框点击事件
mTXCloudVideoView.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
//在这里实现点击重新回到Activity
Intentintent=newIntent(FloatVideoWindowService.this,TRTCVideoCallActivity.class);
startActivity(intent);
}
});

}

//开始触控的坐标，移动时的坐标（相对于屏幕左上角的坐标）
privateintmTouchStartX,mTouchStartY,mTouchCurrentX,mTouchCurrentY;
//开始时的坐标和结束时的坐标（相对于自身控件的坐标）
privateintmStartX,mStartY,mStopX,mStopY;
//判断悬浮窗口是否移动，这里做个标记，防止移动后松手触发了点击事件
privatebooleanisMove;

privateclassFloatingListenerimplementsView.OnTouchListener{

@Override
publicbooleanonTouch(Viewv,MotionEventevent){
intaction=event.getAction();
switch(action){
caseMotionEvent.ACTION_DOWN:
isMove=false;
mTouchStartX=(int)event.getRawX();
mTouchStartY=(int)event.getRawY();
mStartX=(int)event.getX();
mStartY=(int)event.getY();
break;
caseMotionEvent.ACTION_MOVE:
mTouchCurrentX=(int)event.getRawX();
mTouchCurrentY=(int)event.getRawY();
wmParams.x+=mTouchCurrentX-mTouchStartX;
wmParams.y+=mTouchCurrentY-mTouchStartY;
mWindowManager.updateViewLayout(mFloatingLayout,wmParams);

mTouchStartX=mTouchCurrentX;
mTouchStartY=mTouchCurrentY;
break;
caseMotionEvent.ACTION_UP:
mStopX=(int)event.getX();
mStopY=(int)event.getY();
if(Math.abs(mStartX-mStopX)>=1||Math.abs(mStartY-mStopY)>=1){
isMove=true;
}
break;
default:
break;
}
//如果是移动事件不触发OnClick事件，防止移动的时候一放手形成点击事件
returnisMove;
}
}

}

Activity中的操作

现在我们将思路了捋一下，假设现在我正在进行视频通话，点击视频最小化按钮，我们应该按顺序执行如下步骤：应该是会出现个悬浮框。我们用mServiceBound保存Service注册状态，后面解绑时候用这个去判断，不能有些从其他页面过来调用OnRestart()方法的会报错说Servicenotregister之类的错误。

/*
*开启悬浮Video服务
*/
privatevoidstartVideoService(){
//最小化Activity
moveTaskToBack(true);
Constents.mVideoViewLayout=mVideoViewLayout;
//开启服务显示悬浮框
IntentfloatVideoIntent=newIntent(this,FloatVideoWindowService.class);
floatVideoIntent.putExtra("userId",currentBigUserId);
mServiceBound=bindService(floatVideoIntent,mVideoCallServiceConnection,Context.BIND_AUTO_CREATE);
}

注意：这里用了一个全部变量 Constents.mVideoViewLayout保存Activity中的mVideoViewLayout，以便在上面的Service中使用。

当我们点击悬浮框的时候，可以使用startActivity(intent)来再次打开我们的activity，这时候视频通话activity会回调onRestart()方法，我们在onRestart()生命周期里面unbind解绑掉悬浮框服务，并且重新设置mVideoViewLayout展示

@Override
protectedvoidonRestart(){
super.onRestart();
//不显示悬浮框
if(mServiceBound){
unbindService(mVideoCallServiceConnection);
mServiceBound=false;
}
TXCloudVideoViewtxCloudVideoView=mVideoViewLayout.getCloudVideoViewByUseId(currentBigUserId);
if(txCloudVideoView==null){
txCloudVideoView=mVideoViewLayout.getCloudVideoViewByIndex(0);
}
if(ConstData.userid.equals(currentBigUserId)){
TXCGLSurfaceViewmTXCGLSurfaceView=txCloudVideoView.getGLSurfaceView();
if(mTXCGLSurfaceView!=null&&mTXCGLSurfaceView.getParent()!=null){
((ViewGroup)mTXCGLSurfaceView.getParent()).removeView(mTXCGLSurfaceView);
txCloudVideoView.addVideoView(mTXCGLSurfaceView);
}
}else{
TextureViewmTextureView=txCloudVideoView.getVideoView();
if(mTextureView!=null&&mTextureView.getParent()!=null){
((ViewGroup)mTextureView.getParent()).removeView(mTextureView);
txCloudVideoView.addVideoView(mTextureView);
}
}
}

视频Activity是在Demo中TRTCMainActivity的基础上修改完善的

视频Activity全部代码如下：

publicclassTRTCVideoCallActivityextendsActivityimplementsView.OnClickListener,
TRTCSettingDialog.ISettingListener,TRTCMoreDialog.IMoreListener,
TRTCVideoViewLayout.ITRTCVideoViewLayoutListener,TRTCVideoViewLayout.OnVideoToChatClickListener,
TRTCCallMessageManager.TRTCVideoCallMessageCancelListener{
privatefinalstaticStringTAG=TRTCVideoCallActivity.class.getSimpleName();

privatebooleanbEnableVideo=true,bEnableAudio=true;
privatebooleanmCameraFront=true;

privateTextViewtvRoomId;
privateImageViewivCamera,ivVoice;
privateTRTCVideoViewLayoutmVideoViewLayout;
//通话计时
privateChronometercallTimeChronometer;

privateTRTCCloudDef.TRTCParamstrtcParams;///TRTCSDK视频通话房间进入所必须的参数
privateTRTCCloudtrtcCloud;///TRTCSDK实例对象
privateTRTCCloudListenerImpltrtcListener;///TRTCSDK回调监听

privateHashSetmRoomMembers=newHashSet<>();

privateintmSdkAppId=-1;
privateStringtrtcCallFrom;
privateStringtrtcCallType;
privateintroomId;
privateStringuserSig;

privateCountDownTimercountDownTimer;

privateImageViewtrtcSmallIv;
privateStringcurrentBigUserId=ConstData.userid;
privateHomeWatchermHomeWatcher;
privatebooleanmServiceBound=false;

/**
*不包含自己的接收人列表（单聊情况）
*/
privateListreceiveUsers=newArrayList<>();

privatestaticclassVideoStream{
StringuserId;
intstreamType;

publicbooleanequals(Objectobj){
if(obj==null||userId==null)returnfalse;
VideoStreamstream=(VideoStream)obj;
return(this.streamType==stream.streamType&&this.userId.equals(stream.userId));
}
}

/**
*定义服务绑定的回调开启视频通话服务连接
*/
privateServiceConnectionmVideoCallServiceConnection=newServiceConnection(){

@Override
publicvoidonServiceConnected(ComponentNamename,IBinderservice){
//获取服务的操作对象
FloatVideoWindowService.MyBinderbinder=(FloatVideoWindowService.MyBinder)service;
binder.getService();
}

@Override
publicvoidonServiceDisconnected(ComponentNamename){

}
};

privateArrayListmVideosInRoom=newArrayList<>();

@Override
protectedvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
//应用运行时，保持屏幕高亮，不锁屏
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
ActivityUtil.addDestoryActivityToMap(TRTCVideoCallActivity.this,TAG);
TRTCCallMessageManager.getInstance().setTRTCVideoCallMessageListener(this);

//获取前一个页面得到的进房参数
Intentintent=getIntent();
longmSdkAppIdTemp=intent.getLongExtra("sdkAppId",0);
mSdkAppId=Integer.parseInt(String.valueOf(mSdkAppIdTemp));
roomId=intent.getIntExtra("roomId",0);
trtcCallFrom=intent.getStringExtra("trtcCallFrom");
trtcCallType=intent.getStringExtra("trtcCallType");
ConstData.currentTrtcCallType=trtcCallType;
ConstData.currentRoomId=roomId+"";
receiveUsers=(List)getIntent().getSerializableExtra("receiveUserList");
userSig=intent.getStringExtra("userSig");
trtcParams=newTRTCCloudDef.TRTCParams(mSdkAppId,ConstData.userid,userSig,roomId,"","");
trtcParams.role=TRTCCloudDef.TRTCRoleAnchor;

//初始化UI控件
initView();

//创建TRTCSDK实例
trtcListener=newTRTCCloudListenerImpl(this);
trtcCloud=TRTCCloud.sharedInstance(this);
trtcCloud.setListener(trtcListener);

//开始进入视频通话房间
enterRoom();

/**倒计时30秒，一次1秒*/
countDownTimer=newCountDownTimer(30*1000,1000){
@Override
publicvoidonTick(longmillisUntilFinished){
//TODOAuto-generatedmethodstub
if(!TRTCVideoCallActivity.this.isFinishing()&&ConstData.enterRoomUserIdSet.size()>0){
countDownTimer.cancel();
}
}

@Override
publicvoidonFinish(){
//倒计时全部结束执行操作
if(!TRTCVideoCallActivity.this.isFinishing()&&ConstData.enterRoomUserIdSet.size()==0){
exitRoom();
}
}
};
countDownTimer.start();
/**
*home键监听相关
*/
mHomeWatcher=newHomeWatcher(this);
mHomeWatcher.setOnHomePressedListener(newHomeWatcher.OnHomePressedListener(){
@Override
publicvoidonHomePressed(){
//按了HOME键
//如果悬浮窗没有显示就开启服务展示悬浮窗
if(!Constents.isShowFloatWindow){
startVideoService();
}
}

@Override
publicvoidonRecentAppsPressed(){
//最近app任务列表按键
if(!Constents.isShowFloatWindow){
startVideoService();
}
}

});
mHomeWatcher.startWatch();

}

@Override
protectedvoidonResume(){
super.onResume();
}

@Override
protectedvoidonDestroy(){
super.onDestroy();
if(countDownTimer!=null){
countDownTimer.cancel();
}
trtcCloud.setListener(null);
TRTCCloud.destroySharedInstance();
ConstData.isEnterTRTCCALL=false;
//解绑不显示悬浮框
if(mServiceBound){
unbindService(mVideoCallServiceConnection);
mServiceBound=false;
}
if(mHomeWatcher!=null){
mHomeWatcher.stopWatch();//在销毁时停止监听，不然会报错的。
}
}

/**
*重写onBackPressed
*屏蔽返回键
*/
@Override
publicvoidonBackPressed(){
//super.onBackPressed();//要去掉这句
}

/**
*初始化界面控件，包括主要的视频显示View，以及底部的一排功能按钮
*/
privatevoidinitView(){
setContentView(R.layout.activity_trtc_video);
trtcSmallIv=(ImageView)findViewById(R.id.trtc_small_iv);
trtcSmallIv.setOnClickListener(this);
initClickableLayout(R.id.ll_camera);
initClickableLayout(R.id.ll_voice);
initClickableLayout(R.id.ll_change_camera);

mVideoViewLayout=(TRTCVideoViewLayout)findViewById(R.id.video_ll_mainview);
mVideoViewLayout.setUserId(trtcParams.userId);
mVideoViewLayout.setListener(this);
mVideoViewLayout.setOnVideoToChatListener(this);
callTimeChronometer=(Chronometer)findViewById(R.id.call_time_chronometer);
ivVoice=(ImageView)findViewById(R.id.iv_mic);
ivCamera=(ImageView)findViewById(R.id.iv_camera);
tvRoomId=(TextView)findViewById(R.id.tv_room_id);
tvRoomId.setText(ConstData.username+"（自己）");
findViewById(R.id.video_ring_off_btn).setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
exitRoom();
/**
*单人通话时
*新增主叫方在接收方未接听前挂断时
*发送消息给接收方让接收方取消响铃页面或者来电弹框
*/
if(trtcCallType.equals(Constents.ONE_TO_ONE_VIDEO_CALL)){
//ConstData.enterRoomUserIdSet.size()==0表示还没有接收方加入房间
if(ConstData.enterRoomUserIdSet.size()==0){
sendDeclineMsg();
}
}
}
});
}

privateLinearLayoutinitClickableLayout(intresId){
LinearLayoutlayout=(LinearLayout)findViewById(resId);
layout.setOnClickListener(this);
returnlayout;
}

/**
*设置视频通话的视频参数：需要TRTCSettingDialog提供的分辨率、帧率和流畅模式等参数
*/
privatevoidsetTRTCCloudParam(){
//大画面的编码器参数设置
//设置视频编码参数，包括分辨率、帧率、码率等等，这些编码参数来自于TRTCSettingDialog的设置
//注意（1）：不要在码率很低的情况下设置很高的分辨率，会出现较大的马赛克
//注意（2）：不要设置超过25FPS以上的帧率，因为电影才使用24FPS，我们一般推荐15FPS，这样能将更多的码率分配给画质
TRTCCloudDef.TRTCVideoEncParamencParam=newTRTCCloudDef.TRTCVideoEncParam();
encParam.videoResolution=TRTCCloudDef.TRTC_VIDEO_RESOLUTION_640_360;
encParam.videoFps=15;
encParam.videoBitrate=600;
encParam.videoResolutionMode=TRTCCloudDef.TRTC_VIDEO_RESOLUTION_MODE_PORTRAIT;
trtcCloud.setVideoEncoderParam(encParam);

TRTCCloudDef.TRTCNetworkQosParamqosParam=newTRTCCloudDef.TRTCNetworkQosParam();
qosParam.controlMode=TRTCCloudDef.VIDEO_QOS_CONTROL_SERVER;
qosParam.preference=TRTCCloudDef.TRTC_VIDEO_QOS_PREFERENCE_CLEAR;
trtcCloud.setNetworkQosParam(qosParam);

trtcCloud.setPriorRemoteVideoStreamType(TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);

}

/**
*加入视频房间：需要TRTCNewViewActivity提供的TRTCParams函数
*/
privatevoidenterRoom(){
//预览前配置默认参数
setTRTCCloudParam();
//开启视频采集预览
if(trtcParams.role==TRTCCloudDef.TRTCRoleAnchor){
startLocalVideo(true);
}
trtcCloud.setBeautyStyle(TRTCCloudDef.TRTC_BEAUTY_STYLE_SMOOTH,5,5,5);

if(trtcParams.role==TRTCCloudDef.TRTCRoleAnchor){
trtcCloud.startLocalAudio();
}

setVideoFillMode(true);
setVideoRotation(true);
enableAudioHandFree(true);
enableGSensor(true);
enableAudioVolumeEvaluation(false);
/**
*2019/08/08
*默认打开是前置摄像头
*前置摄像头就设置镜像true
*/
enableVideoEncMirror(true);

setLocalViewMirrorMode(TRTCCloudDef.TRTC_VIDEO_MIRROR_TYPE_AUTO);

mVideosInRoom.clear();
mRoomMembers.clear();

trtcCloud.enterRoom(trtcParams,TRTCCloudDef.TRTC_APP_SCENE_VIDEOCALL);

}

/**
*退出视频房间
*/
privatevoidexitRoom(){
if(trtcCloud!=null){
trtcCloud.exitRoom();
}
ToastUtil.toastShortMessage("通话已结束");
}

@Override
publicvoidonClick(Viewv){
if(v.getId()==R.id.trtc_small_iv){
startVideoService();
}elseif(v.getId()==R.id.ll_camera){
onEnableVideo();
}elseif(v.getId()==R.id.ll_voice){
onEnableAudio();
}elseif(v.getId()==R.id.ll_change_camera){
onChangeCamera();
}
}

/**
*发送挂断/拒接电话消息
*/
privatevoidsendDeclineMsg(){
TIMMessagetimMessage=newTIMMessage();
TIMCustomElemele=newTIMCustomElem();
/**
*挂断/拒接语音、视频通话消息
*msgContent不放内容
*/
StringmsgStr=null;
if(trtcCallType.equals(Constents.ONE_TO_ONE_AUDIO_CALL)
||trtcCallType.equals(Constents.ONE_TO_MULTIPE_AUDIO_CALL)){
msgStr=JsonUtil.toJson(Constents.AUDIO_CALL_MESSAGE_DECLINE_DESC,null);
}elseif(trtcCallType.equals(Constents.ONE_TO_ONE_VIDEO_CALL)
||trtcCallType.equals(Constents.ONE_TO_MULTIPE_VIDEO_CALL)){
msgStr=JsonUtil.toJson(Constents.VIDEO_CALL_MESSAGE_DECLINE_DESC,null);
}
ele.setData(msgStr.getBytes());
timMessage.addElement(ele);

StringreceiveUserId=null;
if(!receiveUsers.isEmpty()){
SampleUsersampleUser=receiveUsers.get(0);
receiveUserId=sampleUser.getUserid();
}
TIMConversationconversation=TIMManager.getInstance().getConversation(
TIMConversationType.C2C,receiveUserId);
//发送消息
conversation.sendOnlineMessage(timMessage,newTIMValueCallBack(){
@Override
publicvoidonError(intcode,Stringdesc){//发送消息失败
//错误码code和错误描述desc，可用于定位请求失败原因
//错误码code含义请参见错误码表
Log.d("NNN","sendmessagefailed.code:"+code+"errmsg:"+desc);
}

@Override
publicvoidonSuccess(TIMMessagemsg){//发送消息成功
Log.e("NNN","SendMsgok");
}
});
}

/**
*开启悬浮Video服务
*/
privatevoidstartVideoService(){
//最小化Activity
moveTaskToBack(true);
Constents.mVideoViewLayout=mVideoViewLayout;
//开启服务显示悬浮框
IntentfloatVideoIntent=newIntent(this,FloatVideoWindowService.class);
floatVideoIntent.putExtra("userId",currentBigUserId);
mServiceBound=bindService(floatVideoIntent,mVideoCallServiceConnection,Context.BIND_AUTO_CREATE);
}

@Override
protectedvoidonRestart(){
super.onRestart();
//不显示悬浮框
if(mServiceBound){
unbindService(mVideoCallServiceConnection);
mServiceBound=false;
}
TXCloudVideoViewtxCloudVideoView=mVideoViewLayout.getCloudVideoViewByUseId(currentBigUserId);
if(txCloudVideoView==null){
txCloudVideoView=mVideoViewLayout.getCloudVideoViewByIndex(0);
}
if(ConstData.userid.equals(currentBigUserId)){
TXCGLSurfaceViewmTXCGLSurfaceView=txCloudVideoView.getGLSurfaceView();
if(mTXCGLSurfaceView!=null&&mTXCGLSurfaceView.getParent()!=null){
((ViewGroup)mTXCGLSurfaceView.getParent()).removeView(mTXCGLSurfaceView);
txCloudVideoView.addVideoView(mTXCGLSurfaceView);
}
}else{
TextureViewmTextureView=txCloudVideoView.getVideoView();
if(mTextureView!=null&&mTextureView.getParent()!=null){
((ViewGroup)mTextureView.getParent()).removeView(mTextureView);
txCloudVideoView.addVideoView(mTextureView);
}
}
}


/**
*开启/关闭视频上行
*/
privatevoidonEnableVideo(){
bEnableVideo=!bEnableVideo;
startLocalVideo(bEnableVideo);
mVideoViewLayout.updateVideoStatus(trtcParams.userId,bEnableVideo);
ivCamera.setImageResource(bEnableVideo?R.mipmap.remote_video_enable:R.mipmap.remote_video_disable);
}

/**
*开启/关闭音频上行
*/
privatevoidonEnableAudio(){
bEnableAudio=!bEnableAudio;
trtcCloud.muteLocalAudio(!bEnableAudio);
ivVoice.setImageResource(bEnableAudio?R.mipmap.mic_enable:R.mipmap.mic_disable);
}

/**
*点击切换摄像头
*/
privatevoidonChangeCamera(){
mCameraFront=!mCameraFront;
onSwitchCamera(mCameraFront);
}

@Override
publicvoidonComplete(){
setTRTCCloudParam();
setVideoFillMode(true);
//moreDlg.updateVideoFillMode(true);
}

/**
*SDK内部状态回调
*/
staticclassTRTCCloudListenerImplextendsTRTCCloudListenerimplementsTRTCCloudListener.TRTCVideoRenderListener{

privateWeakReferencemContext;
privateHashMapmCustomRender;

publicTRTCCloudListenerImpl(TRTCVideoCallActivityactivity){
super();
mContext=newWeakReference<>(activity);
mCustomRender=newHashMap<>(10);
}

/**
*加入房间
*/
@Override
publicvoidonEnterRoom(longelapsed){
finalTRTCVideoCallActivityactivity=mContext.get();
if(activity!=null){
activity.mVideoViewLayout.onRoomEnter();
activity.updateCloudMixtureParams();
activity.callTimeChronometer.setBase(SystemClock.elapsedRealtime());
activity.callTimeChronometer.start();
}
}

/**
*离开房间
*/
@Override
publicvoidonExitRoom(intreason){
TRTCVideoCallActivityactivity=mContext.get();
ConstData.enterRoomUserIdSet.clear();
ConstData.receiveUserSet.clear();
ConstData.isEnterTRTCCALL=false;
Log.e(TAG,"onExitRoom:11111111111111111111");
if(activity!=null){
activity.callTimeChronometer.stop();
activity.finish();
}
}

/**
*ERROR大多是不可恢复的错误，需要通过UI提示用户
*/
@Override
publicvoidonError(interrCode,StringerrMsg,BundleextraInfo){
Log.d(TAG,"sdkcallbackonError");
TRTCVideoCallActivityactivity=mContext.get();
if(activity==null){
return;
}
if(errCode==TXLiteAVCode.ERR_ROOM_REQUEST_TOKEN_HTTPS_TIMEOUT||
errCode==TXLiteAVCode.ERR_ROOM_REQUEST_IP_TIMEOUT||
errCode==TXLiteAVCode.ERR_ROOM_REQUEST_ENTER_ROOM_TIMEOUT){
Toast.makeText(activity,"进房超时，请检查网络或稍后重试:"+errCode+"["+errMsg+"]",Toast.LENGTH_SHORT).show();
activity.exitRoom();
return;
}

if(errCode==TXLiteAVCode.ERR_ROOM_REQUEST_TOKEN_INVALID_PARAMETER||
errCode==TXLiteAVCode.ERR_ENTER_ROOM_PARAM_NULL||
errCode==TXLiteAVCode.ERR_SDK_APPID_INVALID||
errCode==TXLiteAVCode.ERR_ROOM_ID_INVALID||
errCode==TXLiteAVCode.ERR_USER_ID_INVALID||
errCode==TXLiteAVCode.ERR_USER_SIG_INVALID){
Toast.makeText(activity,"进房参数错误:"+errCode+"["+errMsg+"]",Toast.LENGTH_SHORT).show();
activity.exitRoom();
return;
}

if(errCode==TXLiteAVCode.ERR_ACCIP_LIST_EMPTY||
errCode==TXLiteAVCode.ERR_SERVER_INFO_UNPACKING_ERROR||
errCode==TXLiteAVCode.ERR_SERVER_INFO_TOKEN_ERROR||
errCode==TXLiteAVCode.ERR_SERVER_INFO_ALLOCATE_ACCESS_FAILED||
errCode==TXLiteAVCode.ERR_SERVER_INFO_GENERATE_SIGN_FAILED||
errCode==TXLiteAVCode.ERR_SERVER_INFO_TOKEN_TIMEOUT||
errCode==TXLiteAVCode.ERR_SERVER_INFO_INVALID_COMMAND||
errCode==TXLiteAVCode.ERR_SERVER_INFO_GENERATE_KEN_ERROR||
errCode==TXLiteAVCode.ERR_SERVER_INFO_GENERATE_TOKEN_ERROR||
errCode==TXLiteAVCode.ERR_SERVER_INFO_DATABASE||
errCode==TXLiteAVCode.ERR_SERVER_INFO_BAD_ROOMID||
errCode==TXLiteAVCode.ERR_SERVER_INFO_BAD_SCENE_OR_ROLE||
errCode==TXLiteAVCode.ERR_SERVER_INFO_ROOMID_EXCHANGE_FAILED||
errCode==TXLiteAVCode.ERR_SERVER_INFO_STRGROUP_HAS_INVALID_CHARS||
errCode==TXLiteAVCode.ERR_SERVER_ACC_TOKEN_TIMEOUT||
errCode==TXLiteAVCode.ERR_SERVER_ACC_SIGN_ERROR||
errCode==TXLiteAVCode.ERR_SERVER_ACC_SIGN_TIMEOUT||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_INVALID_ROOMID||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_CREATE_ROOM_FAILED||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_SIGN_ERROR||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_SIGN_TIMEOUT||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_ADD_USER_FAILED||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_FIND_USER_FAILED||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_SWITCH_TERMINATION_FREQUENTLY||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_LOCATION_NOT_EXIST||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_ROUTE_TABLE_ERROR||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_INVALID_PARAMETER){
Toast.makeText(activity,"进房失败，请稍后重试:"+errCode+"["+errMsg+"]",Toast.LENGTH_SHORT).show();
activity.exitRoom();
return;
}

if(errCode==TXLiteAVCode.ERR_SERVER_CENTER_ROOM_FULL||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_REACH_PROXY_MAX){
Toast.makeText(activity,"进房失败，房间满了，请稍后重试:"+errCode+"["+errMsg+"]",Toast.LENGTH_SHORT).show();
activity.exitRoom();
return;
}

if(errCode==TXLiteAVCode.ERR_SERVER_CENTER_ROOM_ID_TOO_LONG){
Toast.makeText(activity,"进房失败，roomID超出有效范围:"+errCode+"["+errMsg+"]",Toast.LENGTH_SHORT).show();
activity.exitRoom();
return;
}

if(errCode==TXLiteAVCode.ERR_SERVER_ACC_ROOM_NOT_EXIST||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_ROOM_NOT_EXIST){
Toast.makeText(activity,"进房失败，请确认房间号正确:"+errCode+"["+errMsg+"]",Toast.LENGTH_SHORT).show();
activity.exitRoom();
return;
}

if(errCode==TXLiteAVCode.ERR_SERVER_INFO_SERVICE_SUSPENDED){
Toast.makeText(activity,"进房失败，请确认腾讯云实时音视频账号状态是否欠费:"+errCode+"["+errMsg+"]",Toast.LENGTH_SHORT).show();
activity.exitRoom();
return;
}

if(errCode==TXLiteAVCode.ERR_SERVER_INFO_PRIVILEGE_FLAG_ERROR||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_NO_PRIVILEDGE_CREATE_ROOM||
errCode==TXLiteAVCode.ERR_SERVER_CENTER_NO_PRIVILEDGE_ENTER_ROOM){
Toast.makeText(activity,"进房失败，无权限进入房间:"+errCode+"["+errMsg+"]",Toast.LENGTH_SHORT).show();
activity.exitRoom();
return;
}

if(errCode<=TXLiteAVCode.ERR_SERVER_SSO_SIG_EXPIRED&&
errCode>=TXLiteAVCode.ERR_SERVER_SSO_INTERNAL_ERROR){
//错误参考https://cloud.tencent.com/document/product/269/1671#.E5.B8.90.E5.8F.B7.E7.B3.BB.E7.BB.9F
Toast.makeText(activity,"进房失败，userSig错误:"+errCode+"["+errMsg+"]",Toast.LENGTH_SHORT).show();
activity.exitRoom();
return;
}
Toast.makeText(activity,"onError:"+errMsg+"["+errCode+"]",Toast.LENGTH_SHORT).show();
}

/**
*WARNING大多是一些可以忽略的事件通知，SDK内部会启动一定的补救机制
*/
@Override
publicvoidonWarning(intwarningCode,StringwarningMsg,BundleextraInfo){
Log.d(TAG,"sdkcallbackonWarning");
}

/**
*有新的用户加入了当前视频房间
*/
@Override
publicvoidonUserEnter(StringuserId){
TRTCVideoCallActivityactivity=mContext.get();
ConstData.enterRoomUserIdSet.add(userId);
if(activity!=null){
//创建一个View用来显示新的一路画面
//TXCloudVideoViewrenderView=activity.mVideoViewLayout.onMemberEnter(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);
TXCloudVideoViewrenderView=activity.mVideoViewLayout.onMemberEnter(userId);
if(renderView!=null){
//设置仪表盘数据显示
renderView.setVisibility(View.VISIBLE);
}
}
}

/**
*有用户离开了当前视频房间
*/
@Override
publicvoidonUserExit(StringuserId,intreason){
TRTCVideoCallActivityactivity=mContext.get();
ConstData.enterRoomUserIdSet.remove(userId);
if(activity!=null){
if(activity.trtcCallFrom.equals(userId)){
activity.exitRoom();
}else{
if(ConstData.enterRoomUserIdSet.size()==0){
activity.exitRoom();
}
}
//停止观看画面
activity.trtcCloud.stopRemoteView(userId);
activity.trtcCloud.stopRemoteSubStreamView(userId);
//更新视频UI
//activity.mVideoViewLayout.onMemberLeave(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);
//activity.mVideoViewLayout.onMemberLeave(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_SUB);
activity.mVideoViewLayout.onMemberLeave(userId);
activity.mVideoViewLayout.onMemberLeave(userId);
activity.mRoomMembers.remove(userId);
activity.updateCloudMixtureParams();
TestRenderVideoFramecustomRender=mCustomRender.get(userId);
if(customRender!=null){
customRender.stop();
mCustomRender.remove(userId);
}
}
}

/**
*有用户屏蔽了画面
*/
@Override
publicvoidonUserVideoAvailable(finalStringuserId,booleanavailable){
TRTCVideoCallActivityactivity=mContext.get();
if(activity!=null){
if(available){
//finalTXCloudVideoViewrenderView=activity.mVideoViewLayout.onMemberEnter(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);
finalTXCloudVideoViewrenderView=activity.mVideoViewLayout.onMemberEnter(userId);
if(renderView!=null){
//启动远程画面的解码和显示逻辑，FillMode可以设置是否显示黑边
activity.trtcCloud.setRemoteViewFillMode(userId,TRTCCloudDef.TRTC_VIDEO_RENDER_MODE_FIT);
activity.trtcCloud.startRemoteView(userId,renderView);
activity.runOnUiThread(newRunnable(){
@Override
publicvoidrun(){
//renderView.setUserId(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);
renderView.setUserId(userId);
}
});
}

activity.mRoomMembers.add(userId);
activity.updateCloudMixtureParams();
}else{
activity.trtcCloud.stopRemoteView(userId);
//activity.mVideoViewLayout.onMemberLeave(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);
activity.mVideoViewLayout.onMemberLeave(userId);

activity.mRoomMembers.remove(userId);
activity.updateCloudMixtureParams();
}
activity.mVideoViewLayout.updateVideoStatus(userId,available);
}

}

@Override
publicvoidonUserSubStreamAvailable(finalStringuserId,booleanavailable){
TRTCVideoCallActivityactivity=mContext.get();
if(activity!=null){
if(available){
//finalTXCloudVideoViewrenderView=activity.mVideoViewLayout.onMemberEnter(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_SUB);
finalTXCloudVideoViewrenderView=activity.mVideoViewLayout.onMemberEnter(userId);
if(renderView!=null){
//启动远程画面的解码和显示逻辑，FillMode可以设置是否显示黑边
activity.trtcCloud.setRemoteSubStreamViewFillMode(userId,TRTCCloudDef.TRTC_VIDEO_RENDER_MODE_FIT);
activity.trtcCloud.startRemoteSubStreamView(userId,renderView);

activity.runOnUiThread(newRunnable(){
@Override
publicvoidrun(){
//renderView.setUserId(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_SUB);
renderView.setUserId(userId);
}
});
}

}else{
activity.trtcCloud.stopRemoteSubStreamView(userId);
//activity.mVideoViewLayout.onMemberLeave(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_SUB);
activity.mVideoViewLayout.onMemberLeave(userId);
}
}
}

/**
*有用户屏蔽了声音
*/
@Override
publicvoidonUserAudioAvailable(StringuserId,booleanavailable){
TRTCVideoCallActivityactivity=mContext.get();
if(activity!=null){
if(available){
//finalTXCloudVideoViewrenderView=activity.mVideoViewLayout.onMemberEnter(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);
finalTXCloudVideoViewrenderView=activity.mVideoViewLayout.onMemberEnter(userId);
if(renderView!=null){
renderView.setVisibility(View.VISIBLE);
}
}
}
}

/**
*首帧渲染回调
*/
@Override
publicvoidonFirstVideoFrame(StringuserId,intstreamType,intwidth,intheight){
TRTCVideoCallActivityactivity=mContext.get();
Log.e(TAG,"onFirstVideoFrame:77777777777777777777777");
if(activity!=null){
//activity.mVideoViewLayout.freshToolbarLayoutOnMemberEnter(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);
activity.mVideoViewLayout.freshToolbarLayoutOnMemberEnter(userId);
}
}

@Override
publicvoidonStartPublishCDNStream(interr,StringerrMsg){

}

@Override
publicvoidonStopPublishCDNStream(interr,StringerrMsg){

}

@Override
publicvoidonRenderVideoFrame(StringuserId,intstreamType,TRTCCloudDef.TRTCVideoFrameframe){
//Log.w(TAG,String.format("onRenderVideoFrameuserId:%s,type:%d",userId,streamType));
}

@Override
publicvoidonUserVoiceVolume(ArrayListuserVolumes,inttotalVolume){
//mContext.get().mVideoViewLayout.resetAudioVolume();
for(inti=0;iremoteQuality){
TRTCVideoCallActivityactivity=mContext.get();
if(activity!=null){
activity.mVideoViewLayout.updateNetworkQuality(localQuality.userId,localQuality.quality);
for(TRTCCloudDef.TRTCQualityqualityInfo:remoteQuality){
activity.mVideoViewLayout.updateNetworkQuality(qualityInfo.userId,qualityInfo.quality);
}
}
}
}

@Override
publicvoidonEnableRemoteVideo(finalStringuserId,booleanenable){
if(enable){
//finalTXCloudVideoViewrenderView=mVideoViewLayout.getCloudVideoViewByUseId(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);
finalTXCloudVideoViewrenderView=mVideoViewLayout.getCloudVideoViewByUseId(userId);
if(renderView!=null){
trtcCloud.setRemoteViewFillMode(userId,TRTCCloudDef.TRTC_VIDEO_RENDER_MODE_FIT);
trtcCloud.startRemoteView(userId,renderView);
runOnUiThread(newRunnable(){
@Override
publicvoidrun(){
//renderView.setUserId(userId+TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);
renderView.setUserId(userId);
mVideoViewLayout.freshToolbarLayoutOnMemberEnter(userId);
}
});
}
}else{
trtcCloud.stopRemoteView(userId);
}
}

@Override
publicvoidonEnableRemoteAudio(StringuserId,booleanenable){
trtcCloud.muteRemoteAudio(userId,!enable);
}

@Override
publicvoidonChangeVideoFillMode(StringuserId,booleanadjustMode){
trtcCloud.setRemoteViewFillMode(userId,adjustMode?TRTCCloudDef.TRTC_VIDEO_RENDER_MODE_FIT:TRTCCloudDef.TRTC_VIDEO_RENDER_MODE_FILL);
}

@Override
publicvoidonChangeVideoShowFrame(StringuserId,StringuserName){
currentBigUserId=userId;
tvRoomId.setText(userName);
}

@Override
publicvoidonSwitchCamera(booleanbCameraFront){
trtcCloud.switchCamera();
/**
*2019/08/08
*此处增加判断
*前置摄像头就设置镜像true
*后置摄像头就不设置镜像false
*/
if(bCameraFront){
enableVideoEncMirror(true);
}else{
enableVideoEncMirror(false);
}
}

/**
*视频里点击进入和某人聊天
*
*@paramuserId
*/
@Override
publicvoidonVideoToChatClick(StringuserId){
IntentchatIntent=newIntent(TRTCVideoCallActivity.this,IMSingleActivity.class);
chatIntent.putExtra(IMKeys.INTENT_ID,userId);
startActivity(chatIntent);
if(!Constents.isShowFloatWindow){
startVideoService();
}
}

/**
*拒接视频通话回调
*/
@Override
publicvoidonTRTCVideoCallMessageCancel(){
exitRoom();
}

@Override
publicvoidonFillModeChange(booleanbFillMode){
setVideoFillMode(bFillMode);
}

@Override
publicvoidonVideoRotationChange(booleanbVertical){
setVideoRotation(bVertical);
}

@Override
publicvoidonEnableAudioCapture(booleanbEnable){
enableAudioCapture(bEnable);
}

@Override
publicvoidonEnableAudioHandFree(booleanbEnable){
enableAudioHandFree(bEnable);
}

@Override
publicvoidonMirrorLocalVideo(intlocalViewMirror){
setLocalViewMirrorMode(localViewMirror);
}

@Override
publicvoidonMirrorRemoteVideo(booleanbMirror){
enableVideoEncMirror(bMirror);
}

@Override
publicvoidonEnableGSensor(booleanbEnable){
enableGSensor(bEnable);
}

@Override
publicvoidonEnableAudioVolumeEvaluation(booleanbEnable){
enableAudioVolumeEvaluation(bEnable);
}

@Override
publicvoidonEnableCloudMixture(booleanbEnable){
updateCloudMixtureParams();
}


privatevoidsetVideoFillMode(booleanbFillMode){
if(bFillMode){
trtcCloud.setLocalViewFillMode(TRTCCloudDef.TRTC_VIDEO_RENDER_MODE_FILL);
}else{
trtcCloud.setLocalViewFillMode(TRTCCloudDef.TRTC_VIDEO_RENDER_MODE_FIT);
}
}

privatevoidsetVideoRotation(booleanbVertical){
if(bVertical){
trtcCloud.setLocalViewRotation(TRTCCloudDef.TRTC_VIDEO_ROTATION_0);
}else{
trtcCloud.setLocalViewRotation(TRTCCloudDef.TRTC_VIDEO_ROTATION_90);
}
}

privatevoidenableAudioCapture(booleanbEnable){
if(bEnable){
trtcCloud.startLocalAudio();
}else{
trtcCloud.stopLocalAudio();
}
}

privatevoidenableAudioHandFree(booleanbEnable){
if(bEnable){
trtcCloud.setAudioRoute(TRTCCloudDef.TRTC_AUDIO_ROUTE_SPEAKER);
}else{
trtcCloud.setAudioRoute(TRTCCloudDef.TRTC_AUDIO_ROUTE_EARPIECE);
}
}

privatevoidenableVideoEncMirror(booleanbMirror){
trtcCloud.setVideoEncoderMirror(bMirror);
}

privatevoidsetLocalViewMirrorMode(intmirrorMode){
trtcCloud.setLocalViewMirror(mirrorMode);
}

privatevoidenableGSensor(booleanbEnable){
if(bEnable){
trtcCloud.setGSensorMode(TRTCCloudDef.TRTC_GSENSOR_MODE_UIFIXLAYOUT);
}else{
trtcCloud.setGSensorMode(TRTCCloudDef.TRTC_GSENSOR_MODE_DISABLE);
}
}

privatevoidenableAudioVolumeEvaluation(booleanbEnable){
if(bEnable){
trtcCloud.enableAudioVolumeEvaluation(300);
mVideoViewLayout.showAllAudioVolumeProgressBar();
}else{
trtcCloud.enableAudioVolumeEvaluation(0);
mVideoViewLayout.hideAllAudioVolumeProgressBar();
}
}

privatevoidupdateCloudMixtureParams(){
//背景大画面宽高
intvideoWidth=720;
intvideoHeight=1280;

//小画面宽高
intsubWidth=180;
intsubHeight=320;

intoffsetX=5;
intoffsetY=50;

intbitrate=200;

intresolution=TRTCCloudDef.TRTC_VIDEO_RESOLUTION_640_360;
switch(resolution){

caseTRTCCloudDef.TRTC_VIDEO_RESOLUTION_160_160:{
videoWidth=160;
videoHeight=160;
subWidth=27;
subHeight=48;
offsetY=20;
bitrate=200;
break;
}
caseTRTCCloudDef.TRTC_VIDEO_RESOLUTION_320_180:{
videoWidth=192;
videoHeight=336;
subWidth=54;
subHeight=96;
offsetY=30;
bitrate=400;
break;
}
caseTRTCCloudDef.TRTC_VIDEO_RESOLUTION_320_240:{
videoWidth=240;
videoHeight=320;
subWidth=54;
subHeight=96;
bitrate=400;
break;
}
caseTRTCCloudDef.TRTC_VIDEO_RESOLUTION_480_480:{
videoWidth=480;
videoHeight=480;
subWidth=72;
subHeight=128;
bitrate=600;
break;
}
caseTRTCCloudDef.TRTC_VIDEO_RESOLUTION_640_360:{
videoWidth=368;
videoHeight=640;
subWidth=90;
subHeight=160;
bitrate=800;
break;
}
caseTRTCCloudDef.TRTC_VIDEO_RESOLUTION_640_480:{
videoWidth=480;
videoHeight=640;
subWidth=90;
subHeight=160;
bitrate=800;
break;
}
caseTRTCCloudDef.TRTC_VIDEO_RESOLUTION_960_540:{
videoWidth=544;
videoHeight=960;
subWidth=171;
subHeight=304;
bitrate=1000;
break;
}
caseTRTCCloudDef.TRTC_VIDEO_RESOLUTION_1280_720:{
videoWidth=720;
videoHeight=1280;
subWidth=180;
subHeight=320;
bitrate=1500;
break;
}
default:
break;
}

TRTCCloudDef.TRTCTranscodingConfigconfig=newTRTCCloudDef.TRTCTranscodingConfig();
config.appId=-1;//请从"实时音视频"控制台的帐号信息中获取
config.bizId=-1;//请进入"实时音视频"控制台https://console.cloud.tencent.com/rav，点击对应的应用，然后进入“帐号信息”菜单中，复制“直播信息”模块中的"bizid"
config.videoWidth=videoWidth;
config.videoHeight=videoHeight;
config.videoGOP=1;
config.videoFramerate=15;
config.videoBitrate=bitrate;
config.audioSampleRate=48000;
config.audioBitrate=64;
config.audioChannels=1;

//设置混流后主播的画面位置
TRTCCloudDef.TRTCMixUserbroadCaster=newTRTCCloudDef.TRTCMixUser();
broadCaster.userId=trtcParams.userId;//以主播uid为broadcaster为例
broadCaster.zOrder=0;
broadCaster.x=0;
broadCaster.y=0;
broadCaster.width=videoWidth;
broadCaster.height=videoHeight;

config.mixUsers=newArrayList<>();
config.mixUsers.add(broadCaster);

//设置混流后各个小画面的位置
intindex=0;
for(StringuserId:mRoomMembers){
TRTCCloudDef.TRTCMixUseraudience=newTRTCCloudDef.TRTCMixUser();
audience.userId=userId;
audience.zOrder=1+index;
if(index<3){
//前三个小画面靠右从下往上铺
audience.x=videoWidth-offsetX-subWidth;
audience.y=videoHeight-offsetY-index*subHeight-subHeight;
audience.width=subWidth;
audience.height=subHeight;
}elseif(index<6){
//后三个小画面靠左从下往上铺
audience.x=offsetX;
audience.y=videoHeight-offsetY-(index-3)*subHeight-subHeight;
audience.width=subWidth;
audience.height=subHeight;
}else{
//最多只叠加六个小画面
}

config.mixUsers.add(audience);
++index;
}

trtcCloud.setMixTranscodingConfig(config);
}

protectedStringstringToMd5(Stringstring){
if(TextUtils.isEmpty(string)){
return"";
}
MessageDigestmd5=null;
try{
md5=MessageDigest.getInstance("MD5");
byte[]bytes=md5.digest(string.getBytes());
Stringresult="";
for(byteb:bytes){
Stringtemp=Integer.toHexString(b&0xff);
if(temp.length()==1){
temp="0"+temp;
}
result+=temp;
}
returnresult;
}catch(NoSuchAlgorithmExceptione){
e.printStackTrace();
}
return"";
}


privatevoidstartLocalVideo(booleanenable){
TXCloudVideoViewlocalVideoView=mVideoViewLayout.getCloudVideoViewByUseId(trtcParams.userId);
if(localVideoView==null){
localVideoView=mVideoViewLayout.getFreeCloudVideoView();
}
localVideoView.setUserId(trtcParams.userId);
localVideoView.setVisibility(View.VISIBLE);
if(enable){
//设置TRTCSDK的状态
trtcCloud.enableCustomVideoCapture(false);
//启动SDK摄像头采集和渲染
trtcCloud.startLocalPreview(mCameraFront,localVideoView);
}else{
trtcCloud.stopLocalPreview();
}
}
}

有评论区小伙伴要求晒出Constents.java，这里我也把这个类分享出来，Constents类主要是定义一些全局变量

Constents完整源码如下：

publicclassConstents{

/**
*1对1语音通话
*/
publicfinalstaticStringONE_TO_ONE_AUDIO_CALL="1";
/**
*1对多语音通话
*/
publicfinalstaticStringONE_TO_MULTIPE_AUDIO_CALL="2";
/**
*1对1视频通话
*/
publicfinalstaticStringONE_TO_ONE_VIDEO_CALL="3";

/**
*1对多视频通话
*/
publicfinalstaticStringONE_TO_MULTIPE_VIDEO_CALL="4";

/**
*实时语音通话消息描述内容
*/
publicfinalstaticStringAUDIO_CALL_MESSAGE_DESC="AUDIO_CALL_MESSAGE_DESC";
/**
*实时视频通话消息描述内容
*/
publicfinalstaticStringVIDEO_CALL_MESSAGE_DESC="VIDEO_CALL_MESSAGE_DESC";

/**
*实时语音通话消息拒接
*/
publicfinalstaticStringAUDIO_CALL_MESSAGE_DECLINE_DESC="AUDIO_CALL_MESSAGE_DECLINE_DESC";
/**
*实时视频通话消息拒接
*/
publicfinalstaticStringVIDEO_CALL_MESSAGE_DECLINE_DESC="VIDEO_CALL_MESSAGE_DECLINE_DESC";

/**
*悬浮窗与TRTCVideoActivity共享的视频View
*/
publicstaticTRTCVideoViewLayoutmVideoViewLayout;

/**
*悬浮窗是否开启
*/
publicstaticbooleanisShowFloatWindow=false;

/**
*语音通话开始计时时间（悬浮窗要显示时间在这里记录开始值）
*/
publicstaticlongaudioCallStartTime;

}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

Android基于腾讯云实时音视频仿微信视频通话最小化悬浮

热门推荐

随机推荐