TXswim
TXswim

TRTC 实时音视频，兼容腾讯、ZEGO内核

新年好呀。本来应该在放假前写完这篇的，比较忙，年前要发一个小版本，所以推迟到了年后了。
新的一年，新的开始，新的征程。

  做为一个多年娱乐社交软件开发者，接触最多的就是接入各种SDK，包括什么友盟、极光、创蓝、腾讯云、阿里云、网易云、亚马逊等等。其中和项目挂钩比较紧的，比如直播、实时语音、实时视频等也比较多，从开始接触到现在，直播接触过七牛云、阿里云、腾讯云、网宿，实时音视频接触过腾讯云、声网、zego。各家的sdk接入方面形形色色，也大同小异。前这段时间项目说需要更换sdk，后续又说可能需要兼容之前的sdk，本来想着换个就换下，反正之前也接触过，后来仔细思考了一下，还是做一个集合工具，兼容两家sdk。
  具体的思路是之前在寻找视频播放器时，他们有播放内核替换的方案，所以在做该功能时，也是借鉴了这个方案，同时也参考了工厂模式和单例模式。

  1.根据业务需要，我们可以先定义一个单例，用来初始化sdk，以及提供业务需要使用的sdk的方法，比如推拉流、开闭麦克风、开闭扬声器、调节声音等，提供这些方法给业务层逻辑调用。
 /**
     * 初始化
     */
    public void initSDKApi() {
        if (mTRTCInterface == null) {
            synchronized (TxTRTCController.class) {
                if (mTRTCInterface == null) {
                    mTRTCInterface = new TxTRTCZego();
                }
            }
        }
    }

   /**
     * 开始播放音乐
     */

    public void startPlayMusic(int id, String path) {
        getSDKEngine().startAudioPlay(id, path);
    }

    /**
     * 恢复播放音乐
     */
    public void resumePlayMusic(int id) {
        getSDKEngine().resumeAudioPlay(id);
    }

    /**
     * 暂停播放音乐
     */
    public void pausePlayMusic(int id) {
        getSDKEngine().pauseAudioPlay(id);
    }

    /**
     * 停止播放音乐
     */
    public void stopPlayMusic(int id) {
        getSDKEngine().stopAudioPlay(id);
    }
 /**
     * 是否静音
     */
    public void setMuteAllAudio(boolean mute) {
        getSDKEngine().setMuteAllAudio(mute);
    }

    /**
     * 发布流
     *
     * @param streamId
     */
    public void startPublishing(String streamId, boolean openMic) {
        getSDKEngine().startPublishingStream(streamId, openMic);
    }

    /**
     * 停止发布
     */
    public void stopPublishing(String streamId) {
        getSDKEngine().stopPublishingStream(streamId);
    }

与业务层相关联的只有这个单例，不管sdk如何改变，都不会影响到业务层的代码逻辑，也不用修改业务层的逻辑，我只需要在这个单例中修改可以了。
具体代码如下：

public class TxTRTCController {
    private static TxTRTCController instance;
    public int mBGMId = 1024;//背景音乐ID
    public int mSoundEffectId = 1025;//音效ID
    private TxTRTCInterface mTRTCInterface;

    public TxTRTCController() {
    }

    public static TxTRTCController getInstance() {
        if (instance == null) {
            synchronized (TxTRTCController.class) {
                if (instance == null) {
                    instance = new TxTRTCController();
                }
            }
        }
        return instance;
    }

    /**
     * 初始化
     */
    public void initSDKApi() {
        if (mTRTCInterface == null) {
            synchronized (TxTRTCController.class) {
                if (mTRTCInterface == null) {
                    mTRTCInterface = new TxTRTCZego();
                }
            }
        }
    }


    public TxTRTCInterface getSDKEngine() {
        initSDKApi();
        return mTRTCInterface;
    }

    /**
     * 登录
     *
     * @param roomId
     */
    public void setLoginRoom(String roomId, boolean video, String quality) {
        if (getSDKEngine() == null) return;
        if(TxNetConstants.SERVER_IS_TEST){
            getSDKEngine().loginRoom(roomId+"dev", video, quality);
        }else {
            getSDKEngine().loginRoom(roomId, video, quality);
        }

    }

    /**
     * 上麦
     */
    public void setUpSeat(String roomId) {
        getSDKEngine().setUpSeat(roomId);
    }

    /**
     * 下麦
     */
    public void setDownSeat(String roomId) {
        getSDKEngine().setDownSeat(roomId);
    }

    /**
     * 退出房间
     */
    public void setLogoutRoom(String roomId) {
        getSDKEngine().logoutRoom(roomId);
    }

    /**
     * 销毁SDK
     */
    public void destroyEngine(String roomId) {
        TxRoomJoinGroupUtil.getInstence().quitGroup(roomId);
        if(mTRTCInterface!=null) {
            getSDKEngine().destroyEngine(roomId);
        }
        mTRTCInterface = null;
    }


    //###########################################################   调用的方法start  #####################################################################################################


    /**
     * 设置监听
     *
     * @param musicListener
     */
    public void setAudioEffectListener(TxTRTCMusicListener musicListener) {
        if(mTRTCInterface instanceof TxTRTCTencent){
            getSDKEngine().setAudioEffectListener(TxTRTCInterface.Audio_BGMId,musicListener);
            getSDKEngine().setAudioEffectListener(TxTRTCInterface.Audio_SoundEffectId,musicListener);
        }else {
            getSDKEngine().setAudioEffectListener(TxTRTCInterface.Audio_BGMId,musicListener);
        }

    }

    /**
     * 开始播放音乐
     */

    public void startPlayMusic(int id, String path) {
        getSDKEngine().startAudioPlay(id, path);
    }

    /**
     * 恢复播放音乐
     */
    public void resumePlayMusic(int id) {
        getSDKEngine().resumeAudioPlay(id);
    }

    /**
     * 暂停播放音乐
     */
    public void pausePlayMusic(int id) {
        getSDKEngine().pauseAudioPlay(id);
    }

    /**
     * 停止播放音乐
     */
    public void stopPlayMusic(int id) {
        getSDKEngine().stopAudioPlay(id);
    }

    /**
     * 设置人声
     */
    public void setAudioVoiceCaptureVolume(int progress) {
        getSDKEngine().setAudioVoiceCaptureVolume(progress);
    }

    /**
     * 设置背景音乐音量
     *
     * @param progress
     */
    public void setAudioMusicVolume(int id, int progress) {
        getSDKEngine().setAudioMusicVolume(id, progress);
    }

    /**
     * 设置监听
     *
     * @param listener
     */
    public void setCallSDKListener(TxTRTCListener listener) {
        getSDKEngine().setCallSDKListener(listener);
    }


    /**
     * 是否关闭麦克风
     */
    public void setMicMute(boolean isMute) {
        getSDKEngine().setMicMute(isMute);
    }

    /**
     * 是否使用扬声器
     * 扬声器还是听筒
     *
     * @param isHandsFree
     */
    public void setHandsFree(boolean isHandsFree) {
        getSDKEngine().setHandsFree(isHandsFree);
    }

    /**
     * 是否静音
     */
    public void setMuteAllAudio(boolean mute) {
        getSDKEngine().setMuteAllAudio(mute);
    }

    /**
     * 发布流
     *
     * @param streamId
     */
    public void startPublishing(String streamId, boolean openMic) {
        getSDKEngine().startPublishingStream(streamId, openMic);
    }

    /**
     * 停止发布
     */
    public void stopPublishing(String streamId) {
        getSDKEngine().stopPublishingStream(streamId);
    }

    /**
     * 停止拉取视频流（所有流）
     */
    public void stopPlayAllVideo(boolean open) {
        getSDKEngine().stopPlayAllVideo(open);
    }


    /**
     * 开启音量回调
     *
     * @param enable
     */
    public void enableAudioSoundLevelMonitor(boolean enable) {
        getSDKEngine().enableAudioSoundLevelMonitor(enable);
    }
  2.既然sdk的逻辑调用抽取出来了，那我们怎么进行内核替换呢。这时我想到了工厂模式，提取出一些抽象方法，将不同的sdk作为工厂对象，这样在单例中，我只需要初始化相应的工厂，获取到相应的对象就行。
public abstract class TxTRTCInterface {
    public static final int Audio_BGMId = 1024;//背景音乐ID
    public static final int Audio_SoundEffectId = 1025;//音效ID

    public abstract void initSDK();//初始化SDK
    public abstract void loginRoom(String roomId, boolean video, String quality);//登录房间
    public abstract void logoutRoom(String roomId);//退出房间
    public abstract  void setUpSeat(String roomId);//上麦
    public abstract  void setDownSeat(String roomId);//下麦
    public abstract  void destroyEngine(String roomId);//销毁引擎
    public abstract  void setAudioEffectListener(int id,TxTRTCMusicListener musicListener);//设置BGM监听
    public abstract  void startAudioPlay(int id,String path);//播放BGM
    public abstract  void resumeAudioPlay(int id);//恢复播放BGM
    public abstract  void pauseAudioPlay(int id);//暂停播放BGM
    public abstract  void stopAudioPlay(int id);//停止播放BGM
    public abstract  void setAudioVoiceCaptureVolume(int progress);//设置人声
    public abstract  void setAudioMusicVolume(int id,int progress);//设置背景音乐声音
    public abstract  void setCallSDKListener(TxTRTCListener listener);//设置SDK回调

    public abstract void setMicMute(boolean isMute);//是否关闭麦克风
    public abstract void setHandsFree(boolean isHandsFree) ;//是否使用扬声器. 扬声器还是听筒
    public abstract void setMuteAllAudio(boolean mute);//是否静音
    public abstract void startPublishingStream(String streamId, boolean openMic);//发布流
    public abstract void stopPublishingStream(String streamId) ;//停止发布
    public abstract void stopPlayAllVideo(boolean open);//  停止拉取流（所有流）
    public abstract void enableAudioSoundLevelMonitor(boolean enable) ;// 开启音量回调
}

抽取的方法大部分sdk都是一样的，当然也有一些sdk有不同的区别，这个就需要单独做一些处理了。
腾讯sdk:

public class TxTRTCTencent extends TxTRTCInterface {

    private TRTCCloud mTRTCCloud;
    private TXAudioEffectManager mAudioManager;

    public TxTRTCTencent() {
        initSDK();
    }

    @Override
    public void initSDK() {
        if (mTRTCCloud == null) {
            synchronized (TxTRTCTencent.class) {
                if (mTRTCCloud == null) {
                    mTRTCCloud = TRTCCloud.sharedInstance(TxBaseApplication.getContext());
                }
                if (mAudioManager == null) mAudioManager = mTRTCCloud.getAudioEffectManager();
            }
        }
    }

    private TRTCCloud getSDKEngine() {
        initSDK();
        return mTRTCCloud;
    }

    @Override
    public void loginRoom(String roomId, boolean video, String quality) {
        if (getSDKEngine() == null) return;
        TRTCCloudDef.TRTCParams tRTCParams = new TRTCCloudDef.TRTCParams((int) TxNetConstants.getTencentImAppid(),
                TxUserControl.getInstance().getUserId(),
                TxPrefUtils.getString(TxNetConstants.User.USER_IMSIG, ""), roomId, "", "");
        tRTCParams.role = TRTCCloudDef.TRTCRoleAnchor;
        setHandsFree(true);
        getSDKEngine().enterRoom(tRTCParams, TRTCCloudDef.TRTC_APP_SCENE_AUDIOCALL);
    }

    @Override
    public void logoutRoom(String roomId) {
        getSDKEngine().exitRoom();
    }

    @Override
    public void setUpSeat(String roomId) {
        getSDKEngine().switchRole(TRTCCloudDef.TRTCRoleAnchor);
        startLocalAudio();
    }

    /**
     * 开启音频预览
     */
    private void startLocalAudio() {
        getSDKEngine().startLocalAudio(TRTCCloudDef.TRTC_AUDIO_QUALITY_SPEECH);
    }

    private void stopLocalAudio() {
        getSDKEngine().stopLocalAudio();
    }

    @Override
    public void setDownSeat(String roomId) {
        getSDKEngine().stopLocalAudio();
        stopAudioPlay(Audio_BGMId);
        getSDKEngine().switchRole(TRTCCloudDef.TRTCRoleAudience);

    }

    @Override
    public void destroyEngine(String roomId) {

        if (mTRTCCloud!= null) {
            stopPlayAllVideo(false);
            getSDKEngine().stopLocalAudio();
            stopPublishingStream(roomId);
            logoutRoom(roomId);
        }
        if (mAudioManager != null) {
            mAudioManager.setMusicObserver(Audio_BGMId, null);
            mAudioManager.setMusicObserver(Audio_SoundEffectId, null);
        }
        TRTCCloud.destroySharedInstance();

        mTRTCCloud = null;
        mAudioManager = null;
    }

    /**
     * 获取背景音乐管理器
     *
     * @return
     */
    private TXAudioEffectManager getAudioManager() {
        if (mAudioManager == null) {
            synchronized (TxTRTCTencent.class) {
                if (mAudioManager == null) mAudioManager = getSDKEngine().getAudioEffectManager();
            }
        }
        return mAudioManager;
    }

    @Override
    public void setAudioEffectListener(int id, TxTRTCMusicListener musicListener) {
        getAudioManager().setMusicObserver(id, null);
        getAudioManager().setMusicObserver(id, new TXAudioEffectManager.TXMusicPlayObserver() {
            @Override
            public void onStart(int id, int errCode) {
                if (errCode != 0) {
                    if (Audio_SoundEffectId == id) {
                        if (musicListener != null) musicListener.playEnd(id);
                    } else {
                        if (musicListener != null) musicListener.playError(id);
                    }
                    return;
                }
                if (musicListener != null) musicListener.playing(id);
            }

            @Override
            public void onPlayProgress(int id, long curPtsMS, long durationMS) {
                if (Audio_BGMId == id) {
                    if (musicListener != null)
                        musicListener.playProgress(curPtsMS, durationMS);
                }
            }

            @Override
            public void onComplete(int id, int errCode) {
                if (errCode != 0) {
                    if (Audio_SoundEffectId == id) {
                        if (musicListener != null) musicListener.playEnd(id);
                    } else {
                        if (musicListener != null) musicListener.playError(id);
                    }
                    return;
                }
                if (musicListener != null) musicListener.playEnd(id);
            }
        });
    }

    @Override
    public void startAudioPlay(int id, String path) {
        TXAudioEffectManager.AudioMusicParam audioMusicParam = new TXAudioEffectManager.AudioMusicParam(id, path);
        audioMusicParam.publish = true; //上行
        getAudioManager().startPlayMusic(audioMusicParam);
    }

    @Override
    public void resumeAudioPlay(int id) {
        getAudioManager().resumePlayMusic(id);
    }

    @Override
    public void pauseAudioPlay(int id) {
        getAudioManager().pausePlayMusic(id);
    }

    @Override
    public void stopAudioPlay(int id) {
        getAudioManager().stopPlayMusic(id);
    }

    @Override
    public void setAudioVoiceCaptureVolume(int progress) {
        getAudioManager().setVoiceCaptureVolume(progress);
    }

    @Override
    public void setAudioMusicVolume(int id, int progress) {
        getAudioManager().setMusicPlayoutVolume(id, progress);
        getAudioManager().setMusicPublishVolume(id, progress);
    }

    @Override
    public void setCallSDKListener(TxTRTCListener listener) {
        getSDKEngine().setListener(null);
        getSDKEngine().setListener(new TRTCCloudListener() {

            @Override
            public void onError(int code, String s, Bundle bundle) {
                super.onError(code, s, bundle);
                if (listener != null) listener.error(code, s);
            }

            @Override
            public void onEnterRoom(long result) {
                super.onEnterRoom(result);
                if (listener != null) listener.enterRoom(result);
            }

            @Override
            public void onExitRoom(int i) {
                super.onExitRoom(i);
            }

            @Override
            public void onRemoteUserEnterRoom(String userId) {
                super.onRemoteUserEnterRoom(userId);

            }

            @Override
            public void onRemoteUserLeaveRoom(String userId, int reason) {
                super.onRemoteUserLeaveRoom(userId, reason);

            }

            @Override
            public void onStartPublishing(int errCode, String errMsg) {
                super.onStartPublishing(errCode, errMsg);
                if (listener != null) listener.publishStreamStateUpdate("",errCode,errMsg);
            }

            @Override
            public void onUserVoiceVolume(ArrayList userVolumes, int i) {
                super.onUserVoiceVolume(userVolumes, i);
                if (listener != null) listener.soundLevelUpdateTencent(userVolumes, i);
            }

            @Override
            public void onUserAudioAvailable(String userId, boolean isVideoAvailable) {
                super.onUserAudioAvailable(userId, isVideoAvailable);
                /**
                 * 远端用户开启/关闭了麦克风
                 * userId 远端用户ID
                 * isVideoAvailable true:远端用户打开麦克风  false:远端用户关闭麦克风
                 */
            }

            @Override
            public void onNetworkQuality(TRTCCloudDef.TRTCQuality trtcQuality, ArrayList arrayList) {
                super.onNetworkQuality(trtcQuality, arrayList);
                if (TRTCCloudDef.TRTC_QUALITY_Bad == trtcQuality.quality
                        || TRTCCloudDef.TRTC_QUALITY_Vbad == trtcQuality.quality
                        || TRTCCloudDef.TRTC_QUALITY_Down == trtcQuality.quality) {
                    if (TRTCCloudDef.TRTC_QUALITY_Down == trtcQuality.quality) {
                        if (listener != null) listener.networkQuality(true);
                    } else {
                        if (listener != null) listener.networkQuality(false);
                    }
                }
            }
        });
    }

    @Override
    public void setMicMute(boolean isMute) {
        getSDKEngine().muteLocalAudio(isMute);
    }

    @Override
    public void setHandsFree(boolean isHandsFree) {
        if (isHandsFree) {
            getSDKEngine().setAudioRoute(TRTCCloudDef.TRTC_AUDIO_ROUTE_SPEAKER);
        } else {
            getSDKEngine().setAudioRoute(TRTCCloudDef.TRTC_AUDIO_ROUTE_EARPIECE);
        }
    }

    @Override
    public void setMuteAllAudio(boolean mute) {
        getSDKEngine().muteAllRemoteAudio(mute);
    }

    @Override
    public void startPublishingStream(String streamId, boolean openMic) {
        startLocalAudio();
        getSDKEngine().startPublishing(streamId, TRTCCloudDef.TRTC_VIDEO_STREAM_TYPE_BIG);
        setMicMute(!openMic);
    }

    @Override
    public void stopPublishingStream(String streamId) {
        stopLocalAudio();
        getSDKEngine().stopPublishing();
    }

    @Override
    public void stopPlayAllVideo(boolean open) {
        if (open) {

        } else {
            getSDKEngine().stopAllRemoteView();
        }
    }

    @Override
    public void enableAudioSoundLevelMonitor(boolean enable) {
        getSDKEngine().enableAudioVolumeEvaluation(enable ? 400 : 0);
    }
}

ZEGOsdk：

public class TxTRTCZego extends TxTRTCInterface {
    private final String Zego_Login_RoomId = "Zego_Login_RoomId";//登录房间的ID
    private ZegoMediaPlayer mBGMMediaPlayer, mSoundEffectMediaPlayer;
    private int mBGMMediaPlayerIndex = -1, mSoundEffectMediaPlayerIndex = -1;
    private TxTRTCMusicListener mMusicListener;
    private TxTRTCListener mTRTCListener;

    public TxTRTCZego() {
        initSDK();
    }

    @Override
    public void initSDK() {
        if (0 == TxUserControl.getInstance().getUserZegoAppID()
                || TextUtils.isEmpty(TxUserControl.getInstance().getUserZegoSign())) return;
        if (ZegoExpressEngine.getEngine() == null) {
            ZegoEngineConfig engineConfig = new ZegoEngineConfig();
            engineConfig.advancedConfig.put("audio_device_mode", "4");
            engineConfig.advancedConfig.put("init_domain_name", TxUserControl.getInstance().getUserZegoAppUrl());
            engineConfig.advancedConfig.put("prep_high_pass_filter", "false");//高通滤波器
            ZegoExpressEngine.setEngineConfig(engineConfig);

            ZegoEngineProfile profile = new ZegoEngineProfile();
            profile.appID = TxUserControl.getInstance().getUserZegoAppID();
            profile.application = (Application) TxUiUtils.getContext();
            profile.appSign = TxUserControl.getInstance().getUserZegoSign();
            profile.scenario = ZegoScenario.GENERAL;
            ZegoExpressEngine.createEngine(profile, new IZegoEventHandler() {
                @Override
                public void onRoomStreamUpdate(String roomID, ZegoUpdateType updateType, ArrayList streamList, JSONObject extendedData) {
                    super.onRoomStreamUpdate(roomID, updateType, streamList, extendedData);
                    if (updateType == ZegoUpdateType.ADD) {
                        for (ZegoStream zegoStream : streamList) {
                            startPlayingStream(zegoStream.streamID, roomID);
                            TxWriteLogSDCard.writeLog("即构Zego--", "开始拉流：" + roomID + "-------" + zegoStream.streamID, null);
                        }
                    } else if (updateType == ZegoUpdateType.DELETE) {// callback in UIThread
                        for (ZegoStream zegoStream : streamList) {
                            stopPlayingStream(zegoStream.streamID);
                            TxWriteLogSDCard.writeLog("即构Zego--", "停止拉流：" + roomID + "-------" + zegoStream.streamID, null);
                        }
                    }

                }


                @Override
                public void onPublisherStateUpdate(String streamID, ZegoPublisherState state, int errorCode, JSONObject extendedData) {
                    super.onPublisherStateUpdate(streamID, state, errorCode, extendedData);
                    if (mTRTCListener != null)
                        mTRTCListener.publishStreamStateUpdate(streamID, errorCode, "");

                }

                @Override
                public void onCapturedSoundLevelUpdate(float soundLevel) {
                    super.onCapturedSoundLevelUpdate(soundLevel);
                    if (mTRTCListener != null) mTRTCListener.soundLevelUpdateZegoMine(soundLevel);
                }

                @Override
                public void onRemoteSoundLevelUpdate(HashMap soundLevels) {
                    super.onRemoteSoundLevelUpdate(soundLevels);
                    if (mTRTCListener != null) mTRTCListener.soundLevelUpdateZegoOther(soundLevels);

                }

                @Override
                public void onRoomStateUpdate(String roomID, ZegoRoomState state, int errorCode, JSONObject extendedData) {
                    super.onRoomStateUpdate(roomID, state, errorCode, extendedData);
                    if (mTRTCListener != null)
                        mTRTCListener.roomStateUpdateZego(roomID, state, errorCode);
                }
            });
            if (ZegoExpressEngine.getEngine() != null) {
                ZegoExpressEngine.getEngine().enableAEC(true);//开/关回声消除
                ZegoExpressEngine.getEngine().enableHeadphoneAEC(false);//是否在使用耳机时开启回声消除
                ZegoExpressEngine.getEngine().enableAGC(false);//音频采集自动增益
                ZegoExpressEngine.getEngine().enableANS(true);//音频采集噪声抑制
            }
        }
    }

    public ZegoExpressEngine getSDKEngine() {
        initSDK();
        return ZegoExpressEngine.getEngine();
    }

    @Override
    public void loginRoom(String roomId, boolean video, String quality) {
        if (getSDKEngine() == null) return;
        try {
            ZegoAudioConfig audioConfig = new ZegoAudioConfig();
            if ("1".equals(quality)) {
                audioConfig.bitrate = 192;
            } else {
                audioConfig.bitrate = 128;
            }
            audioConfig.channel = ZegoAudioChannel.STEREO;
            audioConfig.codecID = ZegoAudioCodecID.NORMAL2;
            getSDKEngine().setAudioConfig(audioConfig);

            TxWriteLogSDCard.writeLog("Zego--", "LoginRoom--" + roomId, null);
            String lastRoomId = null;
            if (Hawk.contains(Zego_Login_RoomId)) {
                lastRoomId = Hawk.get(Zego_Login_RoomId, "");
            }
            if (!TextUtils.isEmpty(lastRoomId) && !lastRoomId.equals(roomId)) {
                getSDKEngine().logoutRoom(lastRoomId);
            }

            ZegoRoomConfig config = new ZegoRoomConfig();
            config.isUserStatusNotify = true;
            Hawk.put(Zego_Login_RoomId, roomId);

            getSDKEngine().loginRoom(roomId, new ZegoUser(TxUserControl.getInstance().getUserId(),
                    TxUserControl.getInstance().getUserName()), config);
        } catch (Exception e) {

        }
    }

    @Override
    public void logoutRoom(String roomId) {
        if (getSDKEngine() == null) return;
        getSDKEngine().logoutRoom();
        Hawk.delete(Zego_Login_RoomId);

        stopPublishingStream(roomId);
        getSDKEngine().stopPreview();
    }

    @Override
    public void setUpSeat(String roomId) {
//        startPublishingStream(roomId,false);
    }

    @Override
    public void setDownSeat(String roomId) {
        setMicMute(true);
        stopAudioPlay(Audio_BGMId);
        stopPublishingStream(roomId);

    }

    @Override
    public void destroyEngine(String roomId) {
        if (ZegoExpressEngine.getEngine() != null) {
            if (!TextUtils.isEmpty(roomId)) {
                logoutRoom(roomId);
                stopPublishingStream(roomId);
                getSDKEngine().stopPreview();
            }
            if (mBGMMediaPlayer != null) {
                getSDKEngine().destroyMediaPlayer(mBGMMediaPlayer);
            }
            if (mSoundEffectMediaPlayer != null) {
                getSDKEngine().destroyMediaPlayer(mSoundEffectMediaPlayer);
            }
        }
        Hawk.delete(Zego_Login_RoomId);
        setAudioEffectListener(0, null);
        setCallSDKListener(null);
        ZegoExpressEngine.destroyEngine(new IZegoDestroyCompletionCallback() {
            @Override
            public void onDestroyCompletion() {

            }
        });
    }

    /**
     * 获取背景音乐管理器
     *
     * @return
     */
    private ZegoMediaPlayer getAudioManager(int id) {
        if (Audio_SoundEffectId == id) {
            if (mSoundEffectMediaPlayer == null) {
                synchronized (TxTRTCTencent.class) {
                    if (mSoundEffectMediaPlayer == null)
                        mSoundEffectMediaPlayer = getSDKEngine().createMediaPlayer();
                    mSoundEffectMediaPlayer.muteLocal(false);//可以控制本地静音播放。
                    mSoundEffectMediaPlayer.enableAux(true);//可以将文件的声音混入正在推的流中。
                    mSoundEffectMediaPlayer.setEventHandler(new MyIZegoMediaPlayerEventHandler());
                    mSoundEffectMediaPlayer.setVolume(99);
                    mSoundEffectMediaPlayerIndex = mSoundEffectMediaPlayer.getIndex();
                }
            }
            return mSoundEffectMediaPlayer;
        } else {
            if (mBGMMediaPlayer == null) {
                synchronized (TxTRTCTencent.class) {
                    if (mBGMMediaPlayer == null)
                        mBGMMediaPlayer = getSDKEngine().createMediaPlayer();
                    mBGMMediaPlayer.muteLocal(false);//可以控制本地静音播放。
                    mBGMMediaPlayer.enableAux(true);//可以将文件的声音混入正在推的流中。
                    mBGMMediaPlayer.setEventHandler(new MyIZegoMediaPlayerEventHandler());
                    mBGMMediaPlayerIndex = mBGMMediaPlayer.getIndex();
                }
            }
            return mBGMMediaPlayer;
        }
    }

    @Override
    public void setAudioEffectListener(int id, TxTRTCMusicListener listener) {
        mMusicListener = listener;
    }

    @Override
    public void startAudioPlay(int id, String path) {
        getAudioManager(id).stop();
        getAudioManager(id).loadResource(path, new IZegoMediaPlayerLoadResourceCallback() {
            @Override
            public void onLoadResourceCallback(int errorCode) {
                if (errorCode == 0) {
                    getAudioManager(id).start();
                } else {
                    if (Audio_SoundEffectId == id) {
                        if (mMusicListener != null) mMusicListener.playEnd(Audio_SoundEffectId);
                    } else {
                        if (mMusicListener != null) mMusicListener.playError(Audio_BGMId);
                    }
                }
            }
        });
    }

    @Override
    public void resumeAudioPlay(int id) {
        getAudioManager(id).resume();
    }

    @Override
    public void pauseAudioPlay(int id) {
        getAudioManager(id).pause();
    }

    @Override
    public void stopAudioPlay(int id) {
        getAudioManager(id).stop();
    }

    @Override
    public void setAudioVoiceCaptureVolume(int progress) {
        getSDKEngine().setCaptureVolume(progress * 2);
    }

    @Override
    public void setAudioMusicVolume(int id, int progress) {
        getAudioManager(id).setVolume(progress * 2);
    }

    @Override
    public void setCallSDKListener(TxTRTCListener listener) {
        mTRTCListener = listener;
    }

    @Override
    public void setMicMute(boolean isMute) {
        getSDKEngine().muteMicrophone(isMute);
    }

    @Override
    public void setHandsFree(boolean isHandsFree) {
        getSDKEngine().setAudioRouteToSpeaker(isHandsFree);
    }

    @Override
    public void setMuteAllAudio(boolean mute) {
        getSDKEngine().muteSpeaker(mute);
    }

    @Override
    public void startPublishingStream(String streamId, boolean openMic) {
        setMicMute(!openMic);
        getSDKEngine().startPublishingStream(streamId);
        TxWriteLogSDCard.writeLog("Zego--", "startPublishingStream--" + streamId, null);
    }

    @Override
    public void stopPublishingStream(String streamId) {
        setMicMute(true);
        getSDKEngine().stopPublishingStream();
    }

    @Override
    public void stopPlayAllVideo(boolean open) {
        getSDKEngine().muteSpeaker(!open);
    }

    @Override
    public void enableAudioSoundLevelMonitor(boolean enable) {
        getSDKEngine().startSoundLevelMonitor(enable ? 400 : 0);
    }

    /**
     * 开始拉流
     *
     * @param streamId
     */
    private void startPlayingStream(String streamId, String roomId) {
        try {
            if (!TextUtils.isEmpty(roomId)) {
                ZegoPlayerConfig config = new ZegoPlayerConfig();
                config.roomID = roomId;
                getSDKEngine().startPlayingStream(streamId, config);
            } else {
                getSDKEngine().startPlayingStream(streamId);
            }
        } catch (Exception e) {
        }
    }

    /**
     * 停止拉流
     *
     * @param streamId
     */
    private void stopPlayingStream(String streamId) {
        try {
            getSDKEngine().stopPlayingStream(streamId);
        } catch (Exception e) {
        }
    }

    private class MyIZegoMediaPlayerEventHandler extends IZegoMediaPlayerEventHandler {

        private static final String TAG = "MyIZegoExpressMediaplay";

        @Override
        public void onMediaPlayerStateUpdate(ZegoMediaPlayer mediaPlayer, ZegoMediaPlayerState state, int errorCode) {
            // 本回调在UI线程被回调, 开发者可以在此进行UI的变化, 例如播放按钮的变化
            if (0 == errorCode) {
                if (state == ZegoMediaPlayerState.PLAYING) {//播放中
                    if (mMusicListener != null)
                        mMusicListener.playing(mBGMMediaPlayerIndex == mediaPlayer.getIndex() ? Audio_BGMId : Audio_SoundEffectId);
                } else if (state == ZegoMediaPlayerState.PAUSING) {//暂停播放
                    if (mBGMMediaPlayerIndex == mediaPlayer.getIndex()) {
                        if (mMusicListener != null) mMusicListener.playPause(Audio_BGMId);
                    } else {
                        if (mMusicListener != null) mMusicListener.playEnd(Audio_SoundEffectId);
                    }
                } else if (state == ZegoMediaPlayerState.PLAY_ENDED) {//播放结束
                    if (mMusicListener != null)
                        mMusicListener.playEnd(mBGMMediaPlayerIndex == mediaPlayer.getIndex() ? Audio_BGMId : Audio_SoundEffectId);
                } else {//不在播放
                    if (mMusicListener != null)
                        mMusicListener.playEnd(mBGMMediaPlayerIndex == mediaPlayer.getIndex() ? Audio_BGMId : Audio_SoundEffectId);
                }
            } else {
                if (mMusicListener != null)
                    mMusicListener.playError(mBGMMediaPlayerIndex == mediaPlayer.getIndex() ? Audio_BGMId : Audio_SoundEffectId);
            }
            TxWriteLogSDCard.writeLog(TAG, "音乐播放回调 onMediaPlayerStateUpdate:" + state + ";" + errorCode);
        }

        @Override
        public void onMediaPlayerNetworkEvent(ZegoMediaPlayer mediaPlayer, ZegoMediaPlayerNetworkEvent networkEvent) {
            // 本回调在UI线程被回调, 开发者可以在此进行UI的变化, 例如网络不好的情况做友好的提示
        }

        @Override
        public void onMediaPlayerPlayingProgress(ZegoMediaPlayer mediaPlayer, long millisecond) {
            // 本回调在UI线程被回调, 开发者可以在此进行UI的变化, 例如进度条的变化
            if (mBGMMediaPlayerIndex == mediaPlayer.getIndex()) {
                if (mMusicListener != null)
                    mMusicListener.playProgress(millisecond, mediaPlayer.getTotalDuration());
            }
        }
    }
}
  3.替换内核 ，只需要单例中在初始化sdk的方法做判断就行
image.png

好了，大致就是这样了

你可能感兴趣的:(TRTC 实时音视频，兼容腾讯、ZEGO内核)

  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • ARM中断处理过程 落汤老狗 嵌入式linux
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1） 算法大师 华为od面试python算法前端
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
  • 简介Shell、zsh、bash zhaosuningsn Shellzshbashshelllinuxbash
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
  • 一分钟学会刷牙，受用终生！ 好易康
    讲真，刷了十几二十年牙，没刷对过一次......来来来，划重点，更重要的是执行：①每天刷牙2次，②每次刷牙2~3分钟，③每3个月更换牙刷。最后，请使用正确的刷牙方法：巴氏（BASS）刷牙法undefined_腾讯视频视频来源ADA美国牙医协会巴氏刷牙法又称龈沟清扫法或水平颤动法。是由美国牙科协会推荐的一种有效去除龈缘附近及龈沟内菌斑的方法。刷牙不仅是刷牙齿，同时也要刷牙龈。因为口腔与细菌的战场就在
  • 华为云分布式缓存服务DCS 8月新特性发布 华为云PaaS服务小智 华为云分布式缓存
    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
  • 抱怨很廉价，别做空想家 Fang2023
    今天在整理浏览器收藏夹的时候，看到一个很多年前保存的一个网页，上面是一支央视公益广告的视频，《我创故我在》。思绪一下子回到了好几年前。还记得第一次无意中在电视上看到这支广告，喜悦之情溢于言表。抱怨很廉价，别做空想家，这句歌词尤其喜欢。听着歌曲，仿佛那时候的潮气蓬勃、意气风发，又回来了，即使此时感到疲惫。【公益】央视公益广告歌曲《我创故我在》_腾讯视频
  • 新能源汽车 BMS 学习笔记篇—BMS 基本定义及分类 WPG大大通 其他笔记汽车BMS经验分享新能源电池
    一、BMS定义1、概念：BMS（BatteryManagementSystem）即电池管理系统，其管理对象是二次电池（充电电池或蓄电池），其主要目的是电池的利用率，防止电池出现过度充电和过度放电，可应用于电动汽车、电瓶车、机器人、无人机等图片来源：腾讯网https://new.qq.com《标准普尔警告，电动汽车电池生产面临供应链和地缘政治风险》2、四大功能①感知和测量：检测电池的电压、电流、温度
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • 使用datepicker和uploadify的冲突解决（IE双击才能打开附件上传对话框） zhanglb12
    在开发的过程当中，IE的兼容无疑是我们的一块绊脚石，在我们使用的如期的datepicker插件和使用上传附件的uploadify插件的时候，两者就产生冲突，只要点击过时间的插件，uploadify上传框要双才能打开ie浏览器提示错误Missinginstancedataforthisdatepicker解决方案//if(.browser.msie&&'9.0'===.browser.version
  • 是“王者荣耀”还是“王者农药”？ 颓废思物者
    近些日子，王者又双叒叕火了。而腾讯公司的老总马化腾也跟着他的游戏在人声鼎沸的汪洋中飘荡——我最先是在公众号文章《腾讯推出游戏未保“双减双打”新措施》中看见了未成年人将减少在线时长限制，非节假日从1.5小时降低至1小时，节假日从3小时减到2小时。心中不由掀起一丝波澜：又有家长对游戏出手了。不过大家心中你知我知，在这场纷争中，必定也带着市场的挤压和变化。除去这些市场变化，我们来探讨几个问题：1.没有游
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • css设置当字数超过限制后以省略号（...）显示 周bro css前端vuecss3html经验分享
    1、文字超出一行，省略超出部分，显示’…’用text-overflow:ellipsis属性来，当然还需要加宽度width属来兼容部分浏览。overflow:hidden;text-overflow:ellipsis;white-space:nowrap;2、多行文本溢出显示省略号display:-webkit-box;-webkit-box-orient:vertical;-webkit-lin
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • macOs mojave 添加hp laserjet 1020 打印机方法。 Coder_Zh
    1.设置--》打印机与扫描仪。2.点击“+”选择IP3.输入地址：（写网络IP），协议选择：hpjetdirect-socket4.使用选项：选择hplaserjet10221.6（没有1020的驱动，但是1022的驱动兼容1020可以使用。）测试OK，可以使用。
  • Rust是否会取代C/C++？Rust与C/C++的较量 AI与编程之窗 源码编译与开发rustc语言c++内存安全并发编程代码安全性能优化
    目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
  • 「鲸灵」获数千万美元B+轮融资，旗下日日团打造团购电商新时代 想想再说可以吗
    小编获悉，社交电商鲸灵集团（以下简称鲸灵）已完成数千万美元B+轮融资，由启明创投领投，IDG资本联合领投，老股东跟投。鲸灵刚于7月完成数亿元B轮融资，由腾讯领投，IDG资本、险峰长青、元璟资本跟投。据小编了解，鲸灵旗下的日日团业务单日交易额已突破100万元。鲸灵创始人&CEO邬强强（花名：鬼谷）曾在阿里巴巴任职9年，曾任聚划算事业部总经理、淘宝开放平台创始人。针对本轮融资，邬强强告诉小编：“社交电
  • Windows安装ciphey编码工具，附一道ciscn编码题例 im-Miclelson CTF工具网络安全
    TA是什么一款智能化的编码分析解码工具，对于CTF中复杂性编码类题目可以快速攻破。编码自动分析解码的神器。如何安装Windows环境Python3.864位（最新的版本不兼容，32位的也不行）PIP直接安装pipinstallciphey-ihttps://pypi.mirrors.ustc.edu.cn/simple/安装后若是出现报错请根据错误代码行数找到对应文件，r修改成rb即可。使用标准语
  • svg图片兼容性和用法优缺点 独行侠_ef93
    svg图片的使用方法第一次来认认真真的研究了下svg图片，之前只是在网上见过，但都是一晃而过也没当回事，最近网站改版看到同事有用到svg格式的图片，想想自己干了几年的重构也没用过，这些细节的知识是应该好好研究研究了。暂时还没研究得完全透切，先记下目前为止所看到的吧不然又给忘了。svg可缩放矢量图形（ScalableVectorGraphics），顾名思义就是任意改变其大小也不会变形，是基于可扩展标
  • 腾讯发表多模态综述，一文详解多模态大模型 存内计算开发者社区 多模态大模型人工智能chatgptAIGC量子计算AI-nativegptagi
    多模态大语言模型（MLLM）是近年来兴起的一个新的研究热点，它利用强大的大语言模型作为大脑来执行多模态任务。MLLM令人惊讶的新兴能力，如基于图像写故事和无OCR的数学推理，在传统方法中是罕见的，这表明了一条通往人工通用智能的潜在道路。在本文中，追踪多模态大模型最新热点，讨论多模态关键技术以及现有在情绪识别上的应用。腾讯AILab发表了一篇关于多模态大模型的最新综述《MM-LLMs:RecentA
  • 互联网大咖分享：三个日常生活细节决定了你能否成为一名产品经理 三不小青年
    生活中的细节和习惯决定了你将来适合从事什么类型的职业乔布斯乔布斯说：“生活中的点点滴滴，在将来的某一天会不自觉的串联起来”，这句话对产品经理这个职业来说最适合不过了。互联网大咖在做分享腾讯高级产品经理在馒头商学院分享，行业型产品经理要具备三点项目思维。实际上，这需要我们在日常生活中都要养成这样的习惯。1项目化管理你的工作时间时间观念一定要强，可以按照李开复的时间管理法则，把事情按照“重要，不重要，
  • 增长黑客和最小可复制的内核 爱思考的糖
    五段-增长黑客的三大步骤生活就像逆水行舟，加入你不能加速，现实中最好的情况，你也就处在一种原地打转的状况。增长，就像一辆车里的加速器。围棋爱好者，水平一直没有进步的原因。是因为没有找到提高下棋水平的增长模式有三个办法可以提高：做死活题，练习做关键决策的能力；打谱，复盘经典案例；找AI陪练。增长黑客的三个实战步骤：第一步，假设：建立最小闭环。从笨办法开始，不怕犯错，代价并不高，你可以勇敢尝试。想知道
  • MacOS Catalina 从源码构建Qt6.2开发库之01: 编译Qt6.2源代码 捕鲸叉 QTmacosc++QT
    安装xcode，cmake，ninjabrewinstallnodemac下安装OpenGL库并使之对各项目可见在macOS上安装OpenGL通常涉及到安装一些依赖库，如MGL、GLUT或者是GLEW等，同时确保LLVM的OpenGL框架和相关工具链的兼容性。以下是一个基本的安装步骤，你可以在终端中执行：安装Homebrew（如果还没有安装的话）：/bin/bash-c"$(curl-fsSLht
  • 哪些网站用python开发 hakesashou python基础知识python
    国内的话，知乎，网易，腾讯，搜狐，金山，豆瓣这些属于用Python比较知名的。大型的项目的话，网易的许多游戏，腾讯的某些网站，搜狐的邮箱，金山的测试框架等等都是或多或少使用了Python。YouTube-视频分享网站，在某些功能上使用到python。Quora-社交问答网站。Google-谷歌在很多项目中用python作为网络应用的后端，如GoogleGroups、Gmail、GoogleMaps
  • 【Python】已解决：TypeError: unsupported operand 屿小夏 pythonjavaandroid
    文章目录一、分析问题背景出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：TypeError:unsupportedoperand一、分析问题背景TypeError:unsupportedoperand是Python中常见的一类错误，通常在尝试对不兼容的数据类型进行操作时发生。比如，当你尝试对字符串和整数进行加法操作时，Python会抛出这一错误。这样的错误通常发
  • 电信星卡19元套餐详情(电信星卡19元流量套餐资费详情介绍) 全网优惠分享
    电信星卡19元套餐详情(电信星卡19元流量套餐资费详情介绍)关注微•信•公•众•号"卡泡泡"就知道啦！首先套餐包含30GB本地流量和5GB全国通用流量，还可以选择自己的号码和归属地，非常适合有需求的用户。运气好的话，可以得到一个昵称。而且这些流量可以满足用户日常生活和工作的需求，月租也比较低，下面详细介绍。1.每月基本费用：39元，套餐内包含：30GB爱奇艺、腾讯视频、优酷视频、西瓜视频、抖音短视
  • Linux下read函数详解 威桑 Linuxlinux服务器运维
    在Linux中，read函数是最常用的系统调用之一，用于从文件或其他输入设备读取数据。它是低级别的I/O操作的核心，直接与操作系统的内核交互，提供了高效的数据读取方式。一、read函数简介read函数的声明如下：#includessize_tread(intfd,void*buf,size_tcount);其中：fd是文件描述符，代表了需要读取的文件或设备。文件描述符可以通过调用open或其他文件
  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析 "小夜猫&小懒虫&小财迷"的男人 鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为
    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
  • 项目中 枚举与注解的结合使用 飞翔的马甲 javaenumannotation
    前言：版本兼容，一直是迭代开发头疼的事，最近新版本加上了支持新题型，如果新创建一份问卷包含了新题型，那旧版本客户端就不支持，如果新创建的问卷不包含新题型，那么新旧客户端都支持。这里面我们通过给问卷类型枚举增加自定义注解的方式完成。顺便巩固下枚举与注解。 一、枚举 1.在创建枚举类的时候，该类已继承java.lang.Enum类，所以自定义枚举类无法继承别的类，但可以实现接口。
  • 【Scala十七】Scala核心十一：下划线_的用法 bit1129 scala
    下划线_在Scala中广泛应用，_的基本含义是作为占位符使用。_在使用时是出问题非常多的地方，本文将不断完善_的使用场景以及所表达的含义   1. 在高阶函数中使用 scala> val list = List(-3,8,7,9) list: List[Int] = List(-3, 8, 7, 9) scala> list.filter(_ > 7) r
  • web缓存基础：术语、http报头和缓存策略 dalan_123 Web
    对于很多人来说，去访问某一个站点，若是该站点能够提供智能化的内容缓存来提高用户体验，那么最终该站点的访问者将络绎不绝。缓存或者对之前的请求临时存储，是http协议实现中最核心的内容分发策略之一。分发路径中的组件均可以缓存内容来加速后续的请求，这是受控于对该内容所声明的缓存策略。接下来将讨web内容缓存策略的基本概念，具体包括如如何选择缓存策略以保证互联网范围内的缓存能够正确处理的您的内容，并谈论下
  • crontab 问题 周凡杨 linuxcrontabunix
      一： 0481-079   Reached   a   symbol   that   is   not   expected.   背景： */5   *   *   *   *  /usr/IBMIHS/rsync.sh 
  • 让tomcat支持2级域名共享session g21121 session
    tomcat默认情况下是不支持2级域名共享session的，所有有些情况下登陆后从主域名跳转到子域名会发生链接session不相同的情况，但是只需修改几处配置就可以了。 打开tomcat下conf下context.xml文件 找到Context标签,修改为如下内容 如果你的域名是www.test.com <Context sessionCookiePath="/path&q
  • web报表工具FineReport常用函数的用法总结（数学和三角函数） 老A不折腾 Webfinereport总结
      ABS ABS(number):返回指定数字的绝对值。绝对值是指没有正负符号的数值。 Number:需要求出绝对值的任意实数。 示例: ABS(-1.5)等于1.5。 ABS(0)等于0。 ABS(2.5)等于2.5。   ACOS ACOS(number):返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。 Number:需要返回角
  • linux 启动java进程 sh文件 墙头上一根草 linuxshelljar
    #!/bin/bash #初始化服务器的进程PId变量 user_pid=0; robot_pid=0; loadlort_pid=0; gateway_pid=0; ######### #检查相关服务器是否启动成功 #说明： #使用JDK自带的JPS命令及grep命令组合，准确查找pid #jps 加 l 参数，表示显示java的完整包路径 #使用awk，分割出pid
  • 我的spring学习笔记5-如何使用ApplicationContext替换BeanFactory aijuans Spring 3 系列
    如何使用ApplicationContext替换BeanFactory？ package onlyfun.caterpillar.device; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import
  • Linux 内存使用方法详细解析 annan211 linux内存Linux内存解析
    来源 http://blog.jobbole.com/45748/ 我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。 一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。 Linux在内存管理上份为两级，一级是线性区，类似于00c73000-00c88000，对应于虚拟内存，它实际上不占用
  • 数据库的单表查询常用命令及使用方法(-) 百合不是茶 oracle函数单表查询
        创建数据库;       --建表 create table bloguser(username varchar2(20),userage number(10),usersex char(2));       创建bloguser表,里面有三个字段     &nbs
  • 多线程基础知识 bijian1013 java多线程threadjava多线程
    一．进程和线程 进程就是一个在内存中独立运行的程序，有自己的地址空间。如正在运行的写字板程序就是一个进程。 “多任务”：指操作系统能同时运行多个进程（程序）。如WINDOWS系统可以同时运行写字板程序、画图程序、WORD、Eclipse等。 线程：是进程内部单一的一个顺序控制流。 线程和进程 a.       每个进程都有独立的
  • fastjson简单使用实例 bijian1013 fastjson
    一.简介         阿里巴巴fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库；包括“序列化”和“反序列化”两部分，它具备如下特征：     
  • 【RPC框架Burlap】Spring集成Burlap bit1129 spring
    Burlap和Hessian同属于codehaus的RPC调用框架，但是Burlap已经几年不更新，所以Spring在4.0里已经将Burlap的支持置为Deprecated,所以在选择RPC框架时，不应该考虑Burlap了。 这篇文章还是记录下Burlap的用法吧，主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成  
  • 【Mahout一】基于Mahout 命令参数含义 bit1129 Mahout
    1. mahout seqdirectory   $ mahout seqdirectory --input (-i) input Path to job input directory(原始文本文件). --output (-o) output The directory pathna
  • linux使用flock文件锁解决脚本重复执行问题 ronin47 linux lock　重复执行
    linux的crontab命令，可以定时执行操作，最小周期是每分钟执行一次。关于crontab实现每秒执行可参考我之前的文章《linux crontab 实现每秒执行》现在有个问题，如果设定了任务每分钟执行一次，但有可能一分钟内任务并没有执行完成，这时系统会再执行任务。导致两个相同的任务在执行。 例如： <? //  test .php
  • java-74-数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 bylijinnan java
    public class OcuppyMoreThanHalf { /** * Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 * two solutions: * 1.O(n) * see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性 * 2.O(nlogn) * 排序。中间
  • linux 系统相关命令 candiio linux
    系统参数 cat /proc/cpuinfo  cpu相关参数 cat /proc/meminfo 内存相关参数 cat /proc/loadavg 负载情况 性能参数 1）top M：按内存使用排序 P：按CPU占用排序 1：显示各CPU的使用情况 k：kill进程 o：更多排序规则 回车：刷新数据 2）ulimit ulimit -a：显示本用户的系统限制参
  • [经营与资产]保持独立性和稳定性对于软件开发的重要意义 comsci 软件开发
         一个软件的架构从诞生到成熟，中间要经过很多次的修正和改造       如果在这个过程中，外界的其它行业的资本不断的介入这种软件架构的升级过程中           那么软件开发者原有的设计思想和开发路线
  • 在CentOS5.5上编译OpenJDK6 Cwind linuxOpenJDK
    几番周折终于在自己的CentOS5.5上编译成功了OpenJDK6，将编译过程和遇到的问题作一简要记录，备查。 0. OpenJDK介绍 OpenJDK是Sun（现Oracle）公司发布的基于GPL许可的Java平台的实现。其优点： 1、它的核心代码与同时期Sun（-> Oracle）的产品版基本上是一样的，血统纯正，不用担心性能问题，也基本上没什么兼容性问题；（代码上最主要的差异是
  • java乱码问题 dashuaifu java乱码问题js中文乱码
    swfupload上传文件参数值为中文传递到后台接收中文乱码     在js中用setPostParams（{"tag" : encodeURI( document.getElementByIdx_x("filetag").value，"utf-8")}）; 然后在servlet中String t
  • cygwin很多命令显示command not found的解决办法 dcj3sjt126com cygwin
    cygwin很多命令显示command not found的解决办法   修改cygwin.BAT文件如下 @echo off D: set CYGWIN=tty notitle glob set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
  • [介绍]从 Yii 1.1 升级 dcj3sjt126com PHPyii2
    2.0 版框架是完全重写的，在 1.1 和 2.0 两个版本之间存在相当多差异。因此从 1.1 版升级并不像小版本间的跨越那么简单，通过本指南你将会了解两个版本间主要的不同之处。 如果你之前没有用过 Yii 1.1，可以跳过本章，直接从"入门篇"开始读起。 请注意，Yii 2.0 引入了很多本章并没有涉及到的新功能。强烈建议你通读整部权威指南来了解所有新特性。这样有可能会发
  • Linux SSH免登录配置总结 eksliang ssh-keygenLinux SSH免登录认证Linux SSH互信
    转载请出自出处：http://eksliang.iteye.com/blog/2187265 一、原理      我们使用ssh-keygen在ServerA上生成私钥跟公钥，将生成的公钥拷贝到远程机器ServerB上后,就可以使用ssh命令无需密码登录到另外一台机器ServerB上。      生成公钥与私钥有两种加密方式，第一种是
  • 手势滑动销毁Activity gundumw100 android
    老是效仿ios，做android的真悲催！ 有需求：需要手势滑动销毁一个Activity 怎么办尼？自己写？ 不用~，网上先问一下百度。 结果： http://blog.csdn.net/xiaanming/article/details/20934541 首先将你需要的Activity继承SwipeBackActivity，它会在你的布局根目录新增一层SwipeBackLay
  • JavaScript变换表格边框颜色 ini JavaScripthtmlWebhtml5css
    效果查看：http://hovertree.com/texiao/js/2.htm代码如下，保存到HTML文件也可以查看效果： <html> <head> <meta charset="utf-8"> <title>表格边框变换颜色代码-何问起</title> </head> <body&
  • Kafka Rest : Confluent kane_xie kafkaRESTconfluent
    最近拿到一个kafka rest的需求，但kafka暂时还没有提供rest api（应该是有在开发中，毕竟rest这么火），上网搜了一下，找到一个Confluent Platform，本文简单介绍一下安装。 这里插一句，给大家推荐一个九尾搜索，原名叫谷粉SOSO，不想fanqiang谷歌的可以用这个。以前在外企用谷歌用习惯了，出来之后用度娘搜技术问题，那匹配度简直感人。 环境声明：Ubu
  • Calender不是单例 men4661273 单例Calender
             在我们使用Calender的时候，使用过Calendar.getInstance()来获取一个日期类的对象，这种方式跟单例的获取方式一样，那么它到底是不是单例呢，如果是单例的话，一个对象修改内容之后，另外一个线程中的数据不久乱套了吗？从试验以及源码中可以得出，Calendar不是单例。 测试： Calendar c1 =
  • 线程内存和主内存之间联系 qifeifei java thread
    1， java多线程共享主内存中变量的时候，一共会经过几个阶段，    lock:将主内存中的变量锁定，为一个线程所独占。   unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量。   read:将主内存中的变量值读到工作内存当中。   load:将read读取的值保存到工作内存中的变量副本中。  
  • schedule和scheduleAtFixedRate tangqi609567707 javatimerschedule
    原文地址：http://blog.csdn.net/weidan1121/article/details/527307 import java.util.Timer;import java.util.TimerTask;import java.util.Date; /** * @author vincent */public class TimerTest {  
  • erlang 部署 wudixiaotie erlang
    1.如果在启动节点的时候报这个错 ： {"init terminating in do_boot",{'cannot load',elf_format,get_files}} 则需要在reltool.config中加入 {app, hipe, [{incl_cond, exclude}]},     2.当generate时，遇到： ERROR
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他