七牛推流SDK demo 中 关键类的注释

最新推荐文章于 2021-05-30 03:28:11 发布
最新推荐文章于 2021-05-30 03:28:11 发布
阅读量2.8k 收藏
点赞数 2
分类专栏： Qiniu 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lipengshiwo/article/details/52849524
版权


SWCodecCameraStreamingActivity

package com.pili.pldroid.streaming.camera.demo;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.util.Log;

import com.pili.pldroid.streaming.CameraStreamingManager;
import com.pili.pldroid.streaming.CameraStreamingManager.EncodingType;
import com.pili.pldroid.streaming.WatermarkSetting;
import com.pili.pldroid.streaming.widget.AspectFrameLayout;
/**
 * Created by jerikc on 15/10/29.
 */
public class SWCodecCameraStreamingActivity extends StreamingBaseActivity {
    private static final String TAG = "SWCodecCameraStreaming";


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //用户使用我们的demon apk进入推流摄像界面，屏幕尺寸大小的控制：
        AspectFrameLayout afl = (AspectFrameLayout) findViewById(R.id.cameraPreview_afl);
        //SHOW_MODE.FULL，可以全屏显示（没有黑边），但是预览的图像和播放的效果有出入,即之前的黑边部分其实没有推流
        //SHOW_MODE.REAL，所见即所得
        afl.setShowMode(AspectFrameLayout.SHOW_MODE.FULL); //  FULL,REAL;
        CameraPreviewFrameView cameraPreviewFrameView =
                (CameraPreviewFrameView) findViewById(R.id.cameraPreview_surfaceView);
        cameraPreviewFrameView.setListener(this);
        //------------------------水印参数设置-------------------------------
        //第二个参数设置水印图片，可以传入本地drawable中的图片，也可以传入图片的绝对路径作为水印资源
        //第三个参数设置水印的位置
        //第四个参数设置水印显示的大小
        //public WatermarkSetting(Context ctx, String absoluteResPath, WATERMARK_LOCATION location, WATERMARK_SIZE size, int alpha)
        WatermarkSetting watermarksetting = new WatermarkSetting(this, R.drawable.qiniu_logo, WatermarkSetting.WATERMARK_LOCATION.NORTH_EAST, WatermarkSetting.WATERMARK_SIZE.MEDIUM, 100);
        //构造带有视频 CameraStremaingManager,需要传入AspectFrameLayout,第四个参数设置编码的方式，硬编or软编
        mCameraStreamingManager = new CameraStreamingManager(this, afl, cameraPreviewFrameView,
                EncodingType.SW_VIDEO_WITH_SW_AUDIO_CODEC); // sw codec

        mCameraStreamingManager.prepare(mCameraStreamingSetting, mMicrophoneStreamingSetting, watermarksetting, mProfile);
        //-----------注册各种Listener----------------------------------------
        //流状态改变回调监听:
        //推流状态回调监听,比如流断开,重连回调
        mCameraStreamingManager.setStreamingStateListener(this);
        //实现StreamStatusCallback 接口的
        mCameraStreamingManager.setSurfaceTextureCallback(this);
        //可以在 StreamingSessionListener 处理一些重连、音频读取失败、preview size 的自定义操作。
        mCameraStreamingManager.setStreamingSessionListener(this);
//        mCameraStreamingManager.setNativeLoggingEnabled(false);
        mCameraStreamingManager.setStreamStatusCallback(this);
        // update the StreamingProfile
//        mProfile.setStream(new Stream(mJSONObject1));
//        mCameraStreamingManager.setStreamingProfile(mProfile);
        setFocusAreaIndicator();
    }
}


StreamingBaseActivity

package com.pili.pldroid.streaming.camera.demo;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.graphics.Bitmap;
import android.hardware.Camera;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.SeekBar;
import android.widget.TextView;
import android.widget.Toast;

import com.pili.pldroid.streaming.CameraStreamingManager;
import com.pili.pldroid.streaming.CameraStreamingSetting;
import com.pili.pldroid.streaming.FrameCapturedCallback;
import com.pili.pldroid.streaming.MicrophoneStreamingSetting;
import com.pili.pldroid.streaming.SharedLibraryNameHelper;
import com.pili.pldroid.streaming.StreamStatusCallback;
import com.pili.pldroid.streaming.StreamingPreviewCallback;
import com.pili.pldroid.streaming.StreamingProfile;
import com.pili.pldroid.streaming.SurfaceTextureCallback;
import com.pili.pldroid.streaming.camera.demo.gles.FBO;
import com.pili.pldroid.streaming.camera.demo.ui.RotateLayout;
import com.qiniu.android.dns.DnsManager;
import com.qiniu.android.dns.IResolver;
import com.qiniu.android.dns.NetworkInfo;
import com.qiniu.android.dns.http.DnspodFree;
import com.qiniu.android.dns.local.AndroidDnsServer;
import com.qiniu.android.dns.local.Resolver;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.util.List;

/**
 * Created by jerikc on 15/7/6.
 */
public class StreamingBaseActivity extends Activity implements
        View.OnLayoutChangeListener,
        StreamStatusCallback,
        StreamingPreviewCallback,
        SurfaceTextureCallback,
        CameraPreviewFrameView.Listener,
        CameraStreamingManager.StreamingSessionListener,
        CameraStreamingManager.StreamingStateListener {

    private static final String TAG = "StreamingBaseActivity";

    private static final int ZOOM_MINIMUM_WAIT_MILLIS = 33; //ms

    private Context mContext;

    protected Button mShutterButton;
    private Button mMuteButton;
    private Button mTorchBtn;
    private Button mCameraSwitchBtn;
    private Button mCaptureFrameBtn;
    private Button mEncodingOrientationSwitcherBtn;
    private Button mFaceBeautyBtn;
    //Filter
    private Button mFilterBtn;
    private RotateLayout mRotateLayout;

    protected TextView mSatusTextView;
    private TextView mLogTextView;
    private TextView mStreamStatus;

    protected boolean mShutterButtonPressed = false;
    private boolean mIsTorchOn = false;
    private boolean mIsNeedMute = false;
    private boolean mIsNeedFB = false;
    private boolean mIsNeedFL = false;
    private boolean isEncOrientationPort = true;

    protected static final int MSG_START_STREAMING  = 0;
    protected static final int MSG_STOP_STREAMING   = 1;
    private static final int MSG_SET_ZOOM           = 2;
    private static final int MSG_MUTE               = 3;
    private static final int MSG_FB                 = 4;
    private static final int MSG_FL                 = 5;
    protected String mStatusMsgContent;

    protected String mLogContent = "\n";

    private View mRootView;

    protected CameraStreamingManager mCameraStreamingManager;
    protected CameraStreamingSetting mCameraStreamingSetting;
    protected MicrophoneStreamingSetting mMicrophoneStreamingSetting;
    protected StreamingProfile mProfile;
    protected JSONObject mJSONObject;
    private boolean mIsNeedSpeedCheck = true;
    private boolean mOrientationChanged = false;

    protected boolean mIsReady = false;

    private int mCurrentZoom = 0;
    private int mMaxZoom = 0;

    private FBO mFBO = new FBO();

    private Screenshooter mScreenshooter = new Screenshooter();
    private EncodingOrientationSwitcher mEncodingOrientationSwitcher = new EncodingOrientationSwitcher();

    protected Handler mHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_START_STREAMING:
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            // disable the shutter button before startStreaming
                            setShutterButtonEnabled(false);
                            boolean res = mCameraStreamingManager.startStreaming();
                            mShutterButtonPressed = true;
                            Log.i(TAG, "res:" + res);
                            if (!res) {
                                mShutterButtonPressed = false;
                                setShutterButtonEnabled(true);
                            }
                            setShutterButtonPressed(mShutterButtonPressed);
                        }
                    }).start();
                    break;
                case MSG_STOP_STREAMING:
                    // disable the shutter button before stopStreaming
                    setShutterButtonEnabled(false);
                    boolean res = mCameraStreamingManager.stopStreaming();
                    if (!res) {
                        mShutterButtonPressed = true;
                        setShutterButtonEnabled(true);
                    }
                    setShutterButtonPressed(mShutterButtonPressed);
                    break;
                case MSG_SET_ZOOM:
                    mCameraStreamingManager.setZoomValue(mCurrentZoom);
                    break;
                case MSG_MUTE:
                    mIsNeedMute = !mIsNeedMute;
                    //-----------------禁音推流--------------------------------------
                    //设置为true为禁止声音推流,默认为falase
                    mCameraStreamingManager.mute(mIsNeedMute);
                    updateMuteButtonText();
                    break;
                case MSG_FB:
                    mIsNeedFB = !mIsNeedFB;
                    mCameraStreamingManager.setVideoFilterType(mIsNeedFB ?
                            CameraStreamingSetting.VIDEO_FILTER_TYPE.VIDEO_FILTER_BEAUTY
                            : CameraStreamingSetting.VIDEO_FILTER_TYPE.VIDEO_FILTER_NONE);
                    updateFBButtonText();
                    break;
                case MSG_FL:
                    mIsNeedFL = !mIsNeedFL;
                    onSurfaceCreated();
                    /*mCameraStreamingManager.setVideoFilterType(mIsNeedFL ?
                            CameraStreamingSetting.VIDEO_FILTER_TYPE.VIDEO_FILTER_BEAUTY
                            : CameraStreamingSetting.VIDEO_FILTER_TYPE.VIDEO_FILTER_NONE);*/
                    updateFLButtonText();
                    break;
                default:
                    Log.e(TAG, "Invalid message");
                    break;
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            requestWindowFeature(Window.FEATURE_ACTION_BAR_OVERLAY);
        } else {
            requestWindowFeature(Window.FEATURE_NO_TITLE);
        }

        super.onCreate(savedInstanceState);

        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

        if (Config.SCREEN_ORIENTATION == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
            isEncOrientationPort = true;
        } else if (Config.SCREEN_ORIENTATION == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
            isEncOrientationPort = false;
        }
        setRequestedOrientation(Config.SCREEN_ORIENTATION);

        setContentView(R.layout.activity_camera_streaming);

        //从MainActivity获取传入的推流的JSON数据
        String streamJsonStrFromServer = getIntent().getStringExtra(Config.EXTRA_KEY_STREAM_JSON);
        Log.i(TAG, "streamJsonStrFromServer:" + streamJsonStrFromServer);

        try {
            mJSONObject = new JSONObject(streamJsonStrFromServer);
        } catch (Exception e) {
            e.printStackTrace();
        }

        mContext = this;

        StreamingProfile.AudioProfile aProfile = new StreamingProfile.AudioProfile(44100, 96 * 1024);
        StreamingProfile.VideoProfile vProfile = new StreamingProfile.VideoProfile(30, 1000 * 1024, 48);
        StreamingProfile.AVProfile avProfile = new StreamingProfile.AVProfile(vProfile, aProfile);
        //------------------------推流参数设置-------------------------------
        mProfile = new StreamingProfile();

        StreamingProfile.Stream stream = new StreamingProfile.Stream(mJSONObject);
        //------------------通过setStream设置推流地址----------------
        mProfile.setStream(stream);
        //-----------------通过setVideoQuality设置推流视频部分质量参数------------
                /*
                    Level   Fps Video Bitrate(Kbps)
                    VIDEO_QUALITY_LOW1 12 150
                    VIDEO_QUALITY_LOW2  15  264
                    VIDEO_QUALITY_LOW3  15  350
                    VIDEO_QUALITY_MEDIUM1 30 512
                    VIDEO_QUALITY_MEDIUM2   30  800
                    VIDEO_QUALITY_MEDIUM3   30  1000
                    VIDEO_QUALITY_HIGH1 30  1200
                    VIDEO_QUALITY_HIGH2 30  1500
                    VIDEO_QUALITY_HIGH3 30  2000
                */
        mProfile.setVideoQuality(StreamingProfile.VIDEO_QUALITY_HIGH3)
                //-----------------通过setAudioQuality设置推流音频部分质量参数------------
                /*
                    Level   Audio Bitrate(Kbps) Audio Sample Rate(Hz)
                    AUDIO_QUALITY_LOW1  18  44100
                    AUDIO_QUALITY_LOW2  24  44100
                    AUDIO_QUALITY_MEDIUM1   32  44100
                    AUDIO_QUALITY_MEDIUM2   48  44100
                    AUDIO_QUALITY_HIGH1 96  44100
                    AUDIO_QUALITY_HIGH2 128 44100
                */
                .setAudioQuality(StreamingProfile.AUDIO_QUALITY_MEDIUM2)
                //setPreferredVideoEncodingSize 自定义设置推流分辨率，此优先级高于setEncodingSizeLevel
//                .setPreferredVideoEncodingSize(960, 544)
                .setEncodingSizeLevel(Config.ENCODING_LEVEL)
                //--------------通过setEncoderRCMode设置质量优先还是码率优先----------------
                //EncoderRCModes.QUALITY_PRIORITY: 质量优先，实际的码率可能高于设置的码率
                //EncoderRCModes.BITRATE_PRIORITY: 码率优先，更精确地码率控制
                //默认值为 EncoderRCModes.QUALITY_PRIORITY
                .setEncoderRCMode(StreamingProfile.EncoderRCModes.QUALITY_PRIORITY)
                //--------------通过AVProfile参数自定义推流音视频码率帧率--------------------
                // 自定义设置音频采样率为44100Hz, 码率为96 * 1024 bps
                // 自定义设置视频帧率为30, 码率为1000 * 1024 bps,最大帧率为48
                //setAVProfile 的优先级高于 Quality，也就是说，当同时调用了 Quality 和 AVProfile 的设置，AVProfile 会覆盖 Quality 的设置值
                .setAVProfile(avProfile)
                .setDnsManager(getMyDnsManager())
                .setStreamStatusConfig(new StreamingProfile.StreamStatusConfig(3))
//                .setEncodingOrientation(StreamingProfile.ENCODING_ORIENTATION.PORT)
                // (lowThreshold,highThreshold,durationLimit,timeout)
                .setSendingBufferProfile(new StreamingProfile.SendingBufferProfile(0.2f, 0.8f, 3.0f, 20 * 1000));
        //----------------------------摄像头设置----------------------------
        mCameraStreamingSetting = new CameraStreamingSetting();
        //------------前后置镜头相关--------
        //通过setCameraId可以指定使用前置摄像头或者是后置摄像头, CAMERA_FACING_FONT为前置, CAMERA_FACING_BACK为后置
        mCameraStreamingSetting.setCameraId(Camera.CameraInfo.CAMERA_FACING_FRONT)
                //-------------对焦相关----------
                //通过setContinuousFocusModeEnabled设置自动对焦
                .setContinuousFocusModeEnabled(true)
                //---------------RecordingHint提升数据源的帧率--------
                //在部分机型开启 Recording Hint 之后，会出现画面卡帧等风险，所以请慎用该API。如果需要实现高 fps 推流，可以考虑开启并加入白名单机制
                .setRecordingHint(false)
                .setBuiltInFaceBeautyEnabled(true)
                .setResetTouchFocusDelayInMs(3000)
                //通过setFocusMode设置对焦模式
                /* FOCUS_MODE_CONTINUOUS_PICTURE 自动对焦(Picture);
                   FOCUS_MODE_CONTINUOUS_VIDEO   自动对焦(Video);
                   FOCUS_MODE_AUTO               手动对焦*/
//                .setFocusMode(CameraStreamingSetting.FOCUS_MODE_CONTINUOUS_PICTURE)
                 //--------------摄像头预览相关---------
                 // 使用 PREVIEW_SIZE_LEVEL 和 PREVIEW_SIZE_RATIO 共同确定一个预览Size
                 //PREVIEW_SIZE_LEVEL和相机预览的清晰度有关系, 设置为SMALL预览的画面会很不清晰
                //PREVIEW_SIZE_RATIO 我们的SDK是提供的两种规格16_9 和 4_3
                .setCameraPrvSizeLevel(CameraStreamingSetting.PREVIEW_SIZE_LEVEL.MEDIUM)
                .setCameraPrvSizeRatio(CameraStreamingSetting.PREVIEW_SIZE_RATIO.RATIO_16_9)
                //--------------美颜相关设置---------
                //参数说明：1，beautyLevel；2，whiten ；3，redden.
                .setFaceBeautySetting(new CameraStreamingSetting.FaceBeautySetting(1.0f, 1.0f, 0.8f))
                .setVideoFilter(CameraStreamingSetting.VIDEO_FILTER_TYPE.VIDEO_FILTER_BEAUTY);
        mIsNeedFB = true;
        mIsNeedFL = true;
        //Filter
        //------------------------麦克风参数配置-----------------------------
        mMicrophoneStreamingSetting = new MicrophoneStreamingSetting();
        //希望增加蓝牙麦克风的支持,可以设置:true
        mMicrophoneStreamingSetting.setBluetoothSCOEnabled(false);

        initUIs();
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "tid:" + Thread.currentThread().getId());
        try {
            //CameraStreamingManager#resume 会进行 Camera 的打开操作，当成功打开后，
            //会返回 STATE.READY 消息，用户可以在接受到 STATE.READY 之后，安全地进行推流操作。
            mCameraStreamingManager.resume();
        } catch (Exception e) {
            Toast.makeText(StreamingBaseActivity.this, "Device open error!", Toast.LENGTH_SHORT).show();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();

        mIsReady = false;
        mShutterButtonPressed = false;
        //退出 CameraStreamingManager，该操作会主动断开当前的流链接，并关闭 Camera 和释放相应的资源。
        mCameraStreamingManager.pause();
        mHandler.removeCallbacksAndMessages(null);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mCameraStreamingManager.destroy();
    }

    protected void setShutterButtonPressed(final boolean pressed) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mShutterButtonPressed = pressed;
                mShutterButton.setPressed(pressed);
            }
        });
    }

    protected void setShutterButtonEnabled(final boolean enable) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mShutterButton.setFocusable(enable);
                mShutterButton.setClickable(enable);
                mShutterButton.setEnabled(enable);
            }
        });
    }

    protected void startStreaming() {
        mHandler.removeCallbacksAndMessages(null);
        mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_START_STREAMING), 50);
    }

    protected void stopStreaming() {
        mHandler.removeCallbacksAndMessages(null);
        mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_STOP_STREAMING), 50);
    }

    @Override
    public boolean onRecordAudioFailedHandled(int err) {
        mCameraStreamingManager.updateEncodingType(CameraStreamingManager.EncodingType.SW_VIDEO_CODEC);
        mCameraStreamingManager.startStreaming();
        return true;
    }

    @Override
    public boolean onRestartStreamingHandled(int err) {
        Log.i(TAG, "onRestartStreamingHandled");
        return mCameraStreamingManager.startStreaming();
    }

    @Override
    public Camera.Size onPreviewSizeSelected(List<Camera.Size> list) {
        Camera.Size size = null;
//        if (list != null) {
//            for (Camera.Size s : list) {
//                size = s;
//                Log.i(TAG, "w:" + s.width + ", h:" + s.height);
//                break;
//                if (s.height < 480) {
//                    continue;
//                } else {
//                    size = s;
//                    break;
//                }
//            }
//        }
//        Log.e(TAG, "selected size :" + size.width + "x" + size.height);
        return size;
    }

    @Override
    public boolean onSingleTapUp(MotionEvent e) {
        Log.i(TAG, "onSingleTapUp X:" + e.getX() + ",Y:" + e.getY());

        if (mIsReady) {
            setFocusAreaIndicator();
            mCameraStreamingManager.doSingleTapUp((int) e.getX(), (int) e.getY());
            return true;
        }
        return false;
    }

    @Override
    public boolean onZoomValueChanged(float factor) {
        if (mIsReady && mCameraStreamingManager.isZoomSupported()) {
            mCurrentZoom = (int) (mMaxZoom * factor);
            mCurrentZoom = Math.min(mCurrentZoom, mMaxZoom);
            mCurrentZoom = Math.max(0, mCurrentZoom);

            Log.d(TAG, "zoom ongoing, scale: " + mCurrentZoom + ",factor:" + factor + ",maxZoom:" + mMaxZoom);
            if (!mHandler.hasMessages(MSG_SET_ZOOM)) {
                mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_SET_ZOOM), ZOOM_MINIMUM_WAIT_MILLIS);
                return true;
            }
        }
        return false;
    }

    private Switcher mSwitcher = new Switcher();

    @Override
    public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
        Log.i(TAG, "view!!!!:" + v);
    }

    @Override
    public void onPreviewFrame(byte[] bytes, Camera camera) {

    }

    @Override
    public boolean onPreviewFrame(byte[] bytes, int width, int height) {
//        deal with the yuv data.
//        long start = System.currentTimeMillis();
//        for (int i = 0; i < bytes.length; i++) {
//            bytes[i] = 0x00;
//        }
//        Log.i(TAG, "old onPreviewFrame cost :" + (System.currentTimeMillis() - start));
        return true;
    }

    @Override
    public void onSurfaceCreated() {
        Log.i(TAG, "onSurfaceCreated");
        mFBO.initialize(this);
    }

    @Override
    public void onSurfaceChanged(int width, int height) {
        Log.i(TAG, "onSurfaceChanged width:" + width + ",height:" + height);
        mFBO.updateSurfaceSize(width, height);
    }

    @Override
    public void onSurfaceDestroyed() {
        Log.i(TAG, "onSurfaceDestroyed");
        mFBO.release();
    }

    @Override
    public int onDrawFrame(int texId, int texWidth, int texHeight, float[] transformMatrix) {
        // newTexId should not equal with texId. texId is from the SurfaceTexture.
        // Otherwise, there is no filter effect.
        int newTexId = mFBO.drawFrame(texId, texWidth, texHeight);
//        Log.i(TAG, "onDrawFrame texId:" + texId + ",newTexId:" + newTexId + ",texWidth:" + texWidth + ",texHeight:" + texHeight);
        return newTexId;
    }
    //推流状态信息
    @Override
    public void notifyStreamStatusChanged(final StreamingProfile.StreamStatus streamStatus) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mStreamStatus.setText("bitrate:" + streamStatus.totalAVBitrate / 1024 + " kbps"
                        + "\naudio:" + streamStatus.audioFps + " fps"
                        + "\nvideo:" + streamStatus.videoFps + " fps");
            }
        });
    }

    private class Switcher implements Runnable {
        @Override
        public void run() {
            mCameraStreamingManager.switchCamera();
        }
    }

    private class EncodingOrientationSwitcher implements Runnable {

        @Override
        public void run() {
            Log.i(TAG, "isEncOrientationPort:" + isEncOrientationPort);
            stopStreaming();
            mOrientationChanged = !mOrientationChanged;
            isEncOrientationPort = !isEncOrientationPort;
            //-------------------设置推流播放端方向-------------------------------
            //设置ENCODING_ORIENTATION.LAND推流播放端会横屏播放
            //设置ENCODING_ORIENTATION.PORT推流播放端会竖屏播放
            mProfile.setEncodingOrientation(isEncOrientationPort ? StreamingProfile.ENCODING_ORIENTATION.PORT : StreamingProfile.ENCODING_ORIENTATION.LAND);
            mCameraStreamingManager.setStreamingProfile(mProfile);
            setRequestedOrientation(isEncOrientationPort ? ActivityInfo.SCREEN_ORIENTATION_PORTRAIT : ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            mCameraStreamingManager.notifyActivityOrientationChanged();
            updateOrientationBtnText();
            Toast.makeText(StreamingBaseActivity.this, Config.HINT_ENCODING_ORIENTATION_CHANGED,
                    Toast.LENGTH_SHORT).show();
            Log.i(TAG, "EncodingOrientationSwitcher -");
        }
    }

    private class Screenshooter implements Runnable {
        @Override
        public void run() {
            final String fileName = "PLStreaming_" + System.currentTimeMillis() + ".jpg";
            //SDK 完成截帧之后，会回调 onFrameCaptured，并将结果以参数的形式返回给调用者。
            mCameraStreamingManager.captureFrame(100, 100, new FrameCapturedCallback() {
                private Bitmap bitmap;

                @Override
                public void onFrameCaptured(Bitmap bmp) {
                    if (bmp == null) {
                        return;
                    }
                    bitmap = bmp;
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                saveToSDCard(fileName, bitmap);
                            } catch (IOException e) {
                                e.printStackTrace();
                            } finally {
                                if (bitmap != null) {
                                    bitmap.recycle();
                                    bitmap = null;
                                }
                            }
                        }
                    }).start();
                }
            });
        }
    }

    private void setTorchEnabled(final boolean enabled) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                String flashlight = enabled ? getString(R.string.flash_light_off) : getString(R.string.flash_light_on);
                mTorchBtn.setText(flashlight);
            }
        });
    }
    //推流过程中流状态信息的一些回调
    @Override
    public void onStateChanged(final int state, Object extra) {
        switch (state) {
            case CameraStreamingManager.STATE.PREPARING:
                mStatusMsgContent = getString(R.string.string_state_preparing);
                break;
            case CameraStreamingManager.STATE.READY:
                // 当流的状态是READY的时候开始推流
                mIsReady = true;
                mMaxZoom = mCameraStreamingManager.getMaxZoom();
                mStatusMsgContent = getString(R.string.string_state_ready);
                // start streaming when READY
                startStreaming();
                break;
            case CameraStreamingManager.STATE.CONNECTING:
                mStatusMsgContent = getString(R.string.string_state_connecting);
                break;
            case CameraStreamingManager.STATE.STREAMING:
                mStatusMsgContent = getString(R.string.string_state_streaming);
                setShutterButtonEnabled(true);
                setShutterButtonPressed(true);
                break;
            case CameraStreamingManager.STATE.SHUTDOWN:
                mStatusMsgContent = getString(R.string.string_state_ready);
                setShutterButtonEnabled(true);
                setShutterButtonPressed(false);
                if (mOrientationChanged) {
                    mOrientationChanged = false;
                    startStreaming();
                }
                break;
            //若网络不可达（网络断开等情况），尝试重连之后，会返回 STATE.IOERROR，可以不用担心循环重连的问题。
            //在网络层会有三次重连的机会，即没有必要在收到 STATE.IOERROR 之后继续进行重连，一般接收到 STATE.IOERROR 代表无法通过网络和服务端建立链接。
            case CameraStreamingManager.STATE.IOERROR:
                mLogContent += "IOERROR\n";
                mStatusMsgContent = getString(R.string.string_state_ready);
                setShutterButtonEnabled(true);
                break;
            case CameraStreamingManager.STATE.UNKNOWN:
                mStatusMsgContent = getString(R.string.string_state_ready);
                break;
            case CameraStreamingManager.STATE.SENDING_BUFFER_EMPTY:
                break;
            case CameraStreamingManager.STATE.SENDING_BUFFER_FULL:
                break;
            case CameraStreamingManager.STATE.AUDIO_RECORDING_FAIL:
                break;
            case CameraStreamingManager.STATE.OPEN_CAMERA_FAIL:
                Log.e(TAG, "Open Camera Fail. id:" + extra);
                break;
            //在网络断开、sendTimeOut 后没有发出数据、网络链接被服务端断开等网络异常后，STATE.DISCONNECTED 消息会被回调
            case CameraStreamingManager.STATE.DISCONNECTED:
                mLogContent += "DISCONNECTED\n";
                break;
            case CameraStreamingManager.STATE.INVALID_STREAMING_URL:
                Log.e(TAG, "Invalid streaming url:" + extra);
                break;
            case CameraStreamingManager.STATE.CAMERA_SWITCHED:
//                mShutterButtonPressed = false;
                if (extra != null) {
                    Log.i(TAG, "current camera id:" + (Integer)extra);
                }
                Log.i(TAG, "camera switched");
                final int currentCamId = (Integer)extra;
                this.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        updateCameraSwitcherButtonText(currentCamId);
                    }
                });
                break;
            case CameraStreamingManager.STATE.TORCH_INFO:
                if (extra != null) {
                    final boolean isSupportedTorch = (Boolean) extra;
                    Log.i(TAG, "isSupportedTorch=" + isSupportedTorch);
                    this.runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            if (isSupportedTorch) {
                                mTorchBtn.setVisibility(View.VISIBLE);
                            } else {
                                mTorchBtn.setVisibility(View.GONE);
                            }
                        }
                    });
                }
                break;
        }
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                if (mLogTextView != null) {
                    mLogTextView.setText(mLogContent);
                }
                mSatusTextView.setText(mStatusMsgContent);
            }
        });
    }

    @Override
    public boolean onStateHandled(final int state, Object extra) {
        switch (state) {
            case CameraStreamingManager.STATE.SENDING_BUFFER_HAS_FEW_ITEMS:
                return false;
            case CameraStreamingManager.STATE.SENDING_BUFFER_HAS_MANY_ITEMS:
                return false;
        }
        return false;
    }

    private void initUIs() {
        mRootView = findViewById(R.id.content);
        mRootView.addOnLayoutChangeListener(this);

        mMuteButton = (Button) findViewById(R.id.mute_btn);
        mShutterButton = (Button) findViewById(R.id.toggleRecording_button);
        mTorchBtn = (Button) findViewById(R.id.torch_btn);
        mCameraSwitchBtn = (Button) findViewById(R.id.camera_switch_btn);
        mCaptureFrameBtn = (Button) findViewById(R.id.capture_btn);
        mFaceBeautyBtn = (Button) findViewById(R.id.fb_btn);
        //Filter
        mFilterBtn = (Button) findViewById(R.id.fl_btn);
        mSatusTextView = (TextView) findViewById(R.id.streamingStatus);

        mLogTextView = (TextView) findViewById(R.id.log_info);
        //推流状态信息回调mStreamStatus初始化
        mStreamStatus = (TextView) findViewById(R.id.stream_status);

        mFaceBeautyBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (!mHandler.hasMessages(MSG_FB)) {
                    mHandler.sendEmptyMessage(MSG_FB);
                }
            }
        });
        //Filter
        mFilterBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(StreamingBaseActivity.this, "Sorry,this fuction will up by the next version", Toast.LENGTH_SHORT).show();
                /*if (!mHandler.hasMessages(MSG_FL)) {
                    mHandler.sendEmptyMessage(MSG_FL);
                }*/
            }
        });

        mMuteButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (!mHandler.hasMessages(MSG_MUTE)) {
                    mHandler.sendEmptyMessage(MSG_MUTE);
                }
                /*客户的操作，在按钮中添加跳转activity的操作，出现黑屏现象？？？*/
                /*Intent intent = new Intent(StreamingBaseActivity.this,MainActivity.class);
                startActivity(intent);*/
            }
        });

        mShutterButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (mShutterButtonPressed) {
                    stopStreaming();
                } else {
                    startStreaming();
                }
            }
        });

        mTorchBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        if (!mIsTorchOn) {
                            mIsTorchOn = true;
                            mCameraStreamingManager.turnLightOn();
                        } else {
                            mIsTorchOn = false;
                            mCameraStreamingManager.turnLightOff();
                        }
                        setTorchEnabled(mIsTorchOn);
                    }
                }).start();
            }
        });
        //postDelayed的作用是延迟多少毫秒后开始运行
        //removeCallbacks方法是删除指定的Runnable对象，使线程对象停止运行。
        mCameraSwitchBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                mHandler.removeCallbacks(mSwitcher);
                mHandler.postDelayed(mSwitcher, 100);
            }
        });

        mCaptureFrameBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                mHandler.removeCallbacks(mScreenshooter);
                mHandler.postDelayed(mScreenshooter, 100);
            }
        });


        mEncodingOrientationSwitcherBtn = (Button) findViewById(R.id.orientation_btn);
        mEncodingOrientationSwitcherBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mHandler.removeCallbacks(mEncodingOrientationSwitcher);
                mHandler.post(mEncodingOrientationSwitcher);
            }
        });

            //进度条-调节美颜效果程度
            SeekBar seekBarBeauty = (SeekBar) findViewById(R.id.beautyLevel_seekBar);
            seekBarBeauty.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
                @Override
                public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                    CameraStreamingSetting.FaceBeautySetting fbSetting = mCameraStreamingSetting.getFaceBeautySetting();
                    fbSetting.beautyLevel = progress / 100.0f;
                    fbSetting.whiten = progress / 100.0f;
                    fbSetting.redden = progress / 100.0f;

                    mCameraStreamingManager.updateFaceBeautySetting(fbSetting);
                }

                @Override
                public void onStartTrackingTouch(SeekBar seekBar) {
                }

                @Override
                public void onStopTrackingTouch(SeekBar seekBar) {
                }
            });

        initButtonText();
    }

    private void initButtonText() {
        updateFLButtonText();  //
        updateCameraSwitcherButtonText(mCameraStreamingSetting.getReqCameraId());
        mCaptureFrameBtn.setText("截帧"); //截屏 Capture
        updateFBButtonText();
        updateMuteButtonText();
        updateOrientationBtnText();
    }

    private void updateOrientationBtnText() {     //横屏和竖屏
        if (isEncOrientationPort) {
            mEncodingOrientationSwitcherBtn.setText("切横屏");//横屏  Land
        } else {
            mEncodingOrientationSwitcherBtn.setText("切竖屏");//竖屏  Port
        }
    }

    protected void setFocusAreaIndicator() {
        if (mRotateLayout == null) {
            mRotateLayout = (RotateLayout)findViewById(R.id.focus_indicator_rotate_layout);
            mCameraStreamingManager.setFocusAreaIndicator(mRotateLayout,
                    mRotateLayout.findViewById(R.id.focus_indicator));
        }
    }

    private void updateFBButtonText() {
        if (mFaceBeautyBtn != null) {
            mFaceBeautyBtn.setText(mIsNeedFB ? "关闭美颜" : "开启美颜");  //美颜开关 FB Off  FB On
        }
    }
    //Filter
    private void updateFLButtonText() {
        if (mFilterBtn != null) {
            mFilterBtn.setText(mIsNeedFL ? "关闭滤镜" : "开启滤镜");  //滤镜开关 FB Off  FB On
        }
    }

    private void updateMuteButtonText() {
        if (mMuteButton != null) {
            mMuteButton.setText(mIsNeedMute ? "恢复声音" : "静音"); //有声 Unmute or 无声 Mute
        }
    }

    private void updateCameraSwitcherButtonText(int camId) {
        if (mCameraSwitchBtn == null) {
            return;
        }
        if (camId == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            mCameraSwitchBtn.setText("后摄"); //后摄 Back
        } else {
            mCameraSwitchBtn.setText("前摄"); //前摄 Front
        }
    }

    private void saveToSDCard(String filename, Bitmap bmp) throws IOException {
        if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            File file = new File(Environment.getExternalStorageDirectory(), filename);
            BufferedOutputStream bos = null;
            try {
                bos = new BufferedOutputStream(new FileOutputStream(file));
                bmp.compress(Bitmap.CompressFormat.PNG, 90, bos);
                bmp.recycle();
                bmp = null;
            } finally {
                if (bos != null) bos.close();
            }

            final String info = "Save frame to:" + Environment.getExternalStorageDirectory().getAbsolutePath() + "/" + filename;
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(mContext, info, Toast.LENGTH_LONG).show();
                }
            });
        }
    }

    private static DnsManager getMyDnsManager() {
        IResolver r0 = new DnspodFree();
        IResolver r1 = AndroidDnsServer.defaultResolver();
        IResolver r2 = null;
        try {
            r2 = new Resolver(InetAddress.getByName("119.29.29.29"));
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        return new DnsManager(NetworkInfo.normal, new IResolver[]{r0, r1, r2});
    }
}




HugoforAndroid
关注
专栏目录
Qt/C++音视频开发80-ffmpeg实现srt推拉流/实时性非常好/音视频同步/支持格式众多
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
07-31 1380
目前互联网上的视频直播有两种，一种是基于RTMP协议的直播，这种直播方式上行推流使用RTMP协议，下行播放使用RTMP，HTTP+FLV或者HLS，直播延时一般大于3秒，广泛应用秀场、游戏、赛事和事件直播，满足了对交互要求不高的场景；另一种是WebRTC协议的直播，这种直播方式使用UDP的协议进行流媒体的分发，直播延时小于1秒，同时连接数一般小于10个，主要应用在视频通话、秀场连麦等应用场景。
从0-1搭建流媒体系统之ZLMediaKit 安装、运行、推流、拉流
最新发布
weixin_44834554的博客
12-29 6863
目前、比较有名的流媒体服务器有ZLMediaKit、srs、live555、eadydarwin等。因为srs是单线程服务、对于多核服务器的支持需要通过部署多个服务来充分利用多核特性，本文主要介绍一种通用的简单的可利用多核特性的流媒体服务器是ZLMediaKit，另外一方面其支持多种流媒体协议 rtsp、rtmp、httpflv、hls、fmp4、webrtc等，而且支持视频的直播、录制等功能。流媒体服务器是流媒体应用的核心系统，是运营商向用户提供视频服务的关键平台。
七牛直播demo项目Android版本
10-11
直播APP技术架构 直播APP涉及到如下几个方面的角色： 直播业务服务器，该服务器主要是验证客户端的权限并在权限合法之后授权客户端推流参数，客户端使用推流参数进行推流。 七牛直播系统，该系统主要根据直播业务服务器的请求来创建直播流，获取直播流信息，提取直播流回看地址等信息。 推流客户端，推流客户端主要工作是从直播业务服务器获取直播推流参数，然后将录制的视频流推送到七牛直播系统。 直播业务服务器一般由客户自行开发，用来和七牛直播系统进行交互，七牛提供服务端的SDK，客户可以很方便地使用适合自己的编程语言的SDK开发包来开发服务端API。 推流客户端一般由客户自行开发，用来和直播业务服务器交互，将视频流推送到七牛直播系统或者从直播业务服务器获取观看地址，然后从七牛直播系统根据地址获取视频内容。 直播APP业务流程 直播APP登录帐号，该账号的合法性和其相关的业务逻辑由直播业务服务器提供和验证。 直播APP从直播业务服务器获取推流的参数信息，准备使用集成在APP中的七牛推流SDK来将视频流推送到七牛直播系统 直播APP从直播业务服务器获取推流参数后，在开始推流时，发送开始信号给业务服务器，业务服务器记录下该直播过程的起始时间，并生成唯一性id给客户端 直播APP开始进行推流，推送的直播流数据将通过SDK直接发送到七牛直播系统，推流协议为RTMP。 其他的直播APP客户可以从直播业务服务器获取当前直播的RTMP或者HLS的地址进行观看，RTMP的实时性要优于HLS，另外七牛提供的直播播放器支持RTMP协议。 直播APP结束推流，同时发送停止推流信号给直播业务服务器，业务服务器记录下该直播过程的结束时间，可选性地让客户命名直播过程，方便未来回放。 直播APP本身也可以获取已直播完成的视频播放地址进行回看。
直播拉流推流测试demo
10-05
该测试demo主要用于测试拉流 和 推流， 其代码类qt av 集成方便，推流的延时也很低，直播拉流的延时也很低
七牛直播demo加载页
guoer9973的专栏
06-01 1505
package com.pili.pldroid.streaming.camera.demo;import android.app.Activity; import android.content.Intent; import android.os.Build; import android.os.Bundle; import android.util.Log; import android.vie
Android推流帧率的设定与实际情况的影响
Hugo.Lee的博客
11-15 4510
如果您在Android平台上通过setVideoFPS设置帧率为30，可能会发现实际帧率只有20FPS，什么原因？ 硬件限制 部分安卓机器的Camera接口无法实现30FPS及以上的数据采集频率，这个问题在很多机型的前置摄像头上尤为明显。 编码不足 我们一般说编码不足是说编码器的计算量太大，机器性能无法胜任，对于Android而言尤为明显。其实Android的CPU核心数
七牛云直播SDK之推流端快速开发
printlnout的博客
11-14 1万+
前言    七牛云直播SDK迭代快，但是官方文档跟不上迭代速度，导致快速开始这部分文档的还没更新，很多被废弃的类、方法还在文档中，本文是基于2.3.0版本进行的快速开发，由于是第一次接触直播，存在着许多不足欢迎批评指正。 官方文档地址：https://developer.qiniu.com/pili/sdk/3718/PLDroidMediaStreaming-quick-start 官方D...
LFRtmp:一个全开源的纯OC实现的RTMP推流SDK支持AAC，H264，美颜滤镜，AMF编解码-源码开源
03-24
LFRtmp iOS SDK ##一。功能特性1：开源全部代码，未内置任何静态库或者框架2：纯OC实现RTMP推流端协议内容3：AAC音频编码，iphone6s以上采用48k...请在ViewController的toggleCapture方法中填入相应的rtmp推流地址。
张萌&韩墨羽——android摄像头推流
Zephyr_0312的博客
08-20 2540
android摄像头推流 功能概述 摄像头推流，是指采集手机摄像头的画面以及麦克风的声音，进行编码之后再推送到直播云平台上。腾讯云 LiteAVSDK 通过 TXLivePusher 接口提供摄像头推流能力，如下是 LiteAVSDK 的简单版 Demo 中演示摄像头推流的相关操作界面： 不绑定腾讯云 SDK 不绑定腾讯云，如果要推流到非腾讯云地址，请在推流前设置 TXLivePushConfi...
Android腾讯云直播开发,笔记：腾讯云直播SDK测试demo
weixin_33817338的博客
05-30 949
看着腾讯直播的官方指导接入SDK，写了一个demo，有点简陋并且没全部demo应用，有空再更新吧，先做个笔记Mark先demo地址import android.content.DialogInterface;import android.content.res.Configuration;import android.content.res.Resources;import android.gra...
Android代码-七牛短视频SDK美颜滤镜水印编辑混音特效
08-06
PLDroidShortVideo PLDroidShortVideo 是七牛推出的一款适用于 Android 平台的短视频 SDK，提供了包括美颜、滤镜、水印、断点录制、分段回删、视频编辑、混音特效、本地/云端存储在内的多种功能，支持高度定制以及二次开发。 1. 功能列表 短视频 SDK 的功能，主要分为 3 大块：拍摄、编辑、上传。 1.1 拍摄功能 功能点 版本 摄像头采集 1.0.0( ) 麦克风采集 1.0.0( ) 静音功能 1.0.0( ) 实时美颜 1.0.0( ) 贴纸特效 1.0.0( ) 大眼/瘦脸 1.0.0( ) 闪光灯开关 1.0.0( ) 第三方美颜接口 1.0.0( ) 第三方滤镜接口 1.0.0( ) 自定义拍摄时长 1.0.0( ) 自定义分辨率 1.0.0( ) 自定义视频帧率 1.0.0( ) 自定义视频码率 1.0.0( ) 支持 1:1 正方形录制 1.0.0( ) 断点拍摄（多段录制） 1.0.0( ) 回删视频 1.0.0( ) H.264 硬编 1.0.0(
java.lang.NoSuchMethodError: No static method getFont
wolfking0608的博客
06-20 1350
最近项目想用点新玩意和组件式开发阿里路由框架--ARouter.但是在集成过程中,老是出现这样一个错误:java.lang.NoSuchMethodError: No static method getFont(Landroid/content/Context;ILandroid/util/TypedValue;ILandroid/widget/TextView;)Landroid/graphic...
Android Studio报错 Multiple dex files define Lcom/qiniu/android/dns/DnsException;
qq_32371277的博客
11-24 1429
转自：http://blog.csdn.net/freedom2028/article/details/8059271 手动编译Android工程时出现com.android.dx.util.DexException: Multiple dex files define，解决方法如下： 删除工程目录下的classes.dex及XXX.apk文件（一般在bin/classes目录下）
一天开发一个播放器Demo：PLDroidPlayer实战
weixin_33874713的博客
12-11 560
上次对播放器ijkPlayer和PLDroidPlayer进行了评测，总体来说： ijkPlayer可以自己裁剪编译，灵活性较好； PLDroidPlayer不能裁剪，所以不需要编译，集成简单 PLDroidPlayer首开速度要快 PLDroidPlayer在软解码条件下CPU和内存消耗较少 这次，我们和PLDroidPlayer玩耍了一下，集成了PLDroidPlayer的SDK，并且P...
Android 使用PLDroidPlayer播放网络视频 根据视频角度自动旋转
时光与梦、
07-11 1万+
最近因为项目需求 ，需要播放网络视频 ，于是乎 研究了一番 ，说说我遇到的那些坑 现在市面上有几个比较主流好用的第三方框架 Vitamio （ 体积比较大，有商业化风险 github:https://github.com/yixia/VitamioBundle/） ijkplayer（B站下开源的框架 体积大 配置环境比较麻烦 github:https://github.com/Bilib
Android实现流播放视频控件，实现秒播，显示网速和加载进度
热门推荐
文艺范的博客
02-24 2万+
1、相信很多从事Android开发的朋友们肯定遇到过需要播放视频的功能，但是呢，Android自带的播放器VideoView大家忍不住想骂娘的感觉，那播放的速度，是在让人恶心，跟乌龟走路一样，慢死，但是网上也有很多朋友分享各种视频播放的控件，也有不错的，单大多是播放url地址的，对于服务器如果以流的形式来的话，感觉也会有些慢，不过也还过的去，我就遇到过，集成别人的，自己测试发现播放速度还行，结果到...
PLDroidPlayer 是 Pili 直播 SDK 的安卓播放器。支持所有直播常用的格式，如：RTMP、HLS、FLV。拥有优秀的功能和特性，如：首屏秒开、追帧优化、丰富的数据和状态回调、硬解软解
王项雨 的博客
01-09 3995
PLDroidPlayer 是 Pili 直播 SDK 的安卓播放器。支持所有直播常用的格式，如：RTMP、HLS、FLV。拥有优秀的功能和特性，如：首屏秒开、追帧优化、丰富的数据和状态回调、硬解软解支持。而且可以根据自己的业务进行高度定制化开发。 https://github.com/pili-engineering/PLDroidPlayer
七牛云推流SDK使用
jbl5501328的博客
12-17 4100
http://www.jianshu.com/p/e4c43c6551d1 七牛云直播Android推流端之开速开发 字数997 阅读339 评论9 喜欢11 前言 在我看来，定性为快速开发的文档应该是毫无障碍的，对着敲应该就能直接运行的。可是由于七牛迭代太快了，文档跟不上代码迭代的速度，导致快速开始这部分文档的还没更新，很多被废弃的类、方法还在文档中，导致
七牛推流SDK-后台推图片示例
Hugo.Lee的博客
08-08 469
package com.qiniu.pili.droid.streaming.demo.activity; import android.content.pm.ActivityInfo; import android.graphics.Bitmap; import android.hardware.Camera; import android.media.AudioFormat; import ...
七牛发布iOS适用的PLMediaStreamingKit推流SDK
资源摘要信息: "PLMediaStreamingKit 是七牛云存储公司推出的面向iOS平台的流媒体推流SDK。该SDK允许开发者在苹果的应用程序中集成流媒体推流功能，从而使得iOS应用能够发送直播视频流到支持的平台。作为一个专业的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值