将mixplayer的demo迁移进项目

android/build.gradle

@@ -25,7 +25,7 @@ apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 
 android {
-    compileSdkVersion 28
+    compileSdkVersion 27
 
     sourceSets {
         main.java.srcDirs += 'src/main/kotlin'
@@ -33,6 +33,10 @@ android {
     defaultConfig {
         minSdkVersion 16
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+        compileOptions {
+            sourceCompatibility JavaVersion.VERSION_1_8
+            targetCompatibility JavaVersion.VERSION_1_8
+        }
     }
     lintOptions {
         disable 'InvalidPackage'
@@ -40,5 +44,8 @@ android {
 }
 
 dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.android.support:appcompat-v7:27.1.1'
+    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
 }

android/src/main/java/com/fgodt/mixplayer/Core.java

@@ -0,0 +1,193 @@
+package com.fgodt.mixplayer;
+
+import android.util.Log;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+
+
+import java.util.Arrays;
+
+/**
+ * Created by rt-zl on 2019/2/15.
+ */
+
+public class Core {
+    static {
+        System.loadLibrary("mixplayer");
+    }
+
+    private native int  setJNI(long mix);
+    private native long createMix();
+    private native void closeMix(long mix,Render render);
+    private native int setPlayUrl(long mix,String url);
+    private native int open(long mix);
+    private native int setMixCall(long mix);
+    private native int setSurface(long mix, Surface surface);
+    private native int selectAudio(long mix, String name);
+    private native int addMixSource(long mix, String name,double stime, double duration);
+    private native double getMediaDuration(long mix);
+    private native int save(long mix, String output);
+    private native void pause(long mix);
+    private native void resume(long mix);
+    private native void seek(long mix, double time);
+    private native int getStatus(long mix);
+
+    private String url;
+
+    private Render render;
+
+    private String output;
+
+    private mixPlayerCallBack callBack;
+
+
+
+    private long mixHandler;
+
+    public void setUrl(String url){
+        this.url = url;
+    }
+
+    public void setSavePath(String output){
+        this.output = output;
+    }
+
+    public void setSurface(Surface surface){
+        // setSurface(mixHandler,surface);
+    }
+
+    public String getUrl(){
+        return this.url;
+    }
+
+
+    public boolean init(Render render){
+        this.render = render;
+        this.mixHandler = createMix();
+        int ret = setJNI(this.mixHandler);
+        if(ret!=0){
+            return false;
+        }
+        this.render.init(this.mixHandler);
+        setMixCall(mixHandler);
+        return true;
+    }
+
+
+    public boolean open(){
+        int ret =setPlayUrl(mixHandler,this.url);
+        if(ret!=0){
+            return false;
+        }
+        ret = open(mixHandler);
+        if(ret!=0){
+            return false;
+        }
+        return true;
+    }
+
+    public boolean save(){
+        int ret = setPlayUrl(mixHandler,this.url);
+        if(ret != 0){
+            return false;
+        }
+        ret = save(mixHandler,this.output);
+        if(ret != 0){
+            return false;
+        }
+        return true;
+    }
+
+    public  long getMixCtx(){
+        return mixHandler;
+    }
+
+    public void mixClose(){
+        render.mixClose();
+        closeMix(mixHandler,render);
+        mixHandler = 0;
+    }
+
+    public void nativeClose(){
+        Log.d("MIXPLAYER","CLOSE");
+        if(this.callBack != null){
+            this.callBack.closeMsg("CLOSE");
+        }
+    }
+
+    public void nativeCall(){
+
+    }
+
+    public void nativeMsg(String msg){
+        Log.d("MIXPLAYER",msg);
+    }
+
+
+    public int mixDataCall(String name,byte[] data,int len){
+        if(name == null || data == null || len <= 0){
+            return 0;
+        }
+        if(this.callBack!=null){
+            int ret = this.callBack.mix_call(name,data,len);
+            return ret;
+        }
+        return 0;
+    }
+
+    public double mixGetDuration() {
+        if (mixHandler > 0)
+            return getMediaDuration(mixHandler);
+        else
+            return -1;
+    }
+
+    public int addMixSource(String name,double stime, double duration){
+        if(mixHandler >0) {
+            return addMixSource(mixHandler,name,stime,duration);
+        }
+        return -1;
+    }
+
+    public void selectAudioSource(String name){
+        selectAudio(mixHandler,name);
+    }
+
+    public void pause(){
+        if(mixHandler>0){
+            pause(mixHandler);
+        }
+    }
+
+    public void resume(){
+        if(mixHandler>0){
+            resume(mixHandler);
+        }
+    }
+
+    public void seek(double time){
+        if(mixHandler>0){
+            seek(mixHandler,time);
+        }
+    }
+
+    void setMixCall(mixPlayerCallBack call){
+        this.callBack = call;
+    }
+
+    public int getStatus(){
+        if(mixHandler>0){
+            return getStatus(mixHandler);
+        }
+        return 1;//stop
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+        //make sure close
+        if(mixHandler!=0)
+            mixClose();
+    }
+
+}

android/src/main/java/com/fgodt/mixplayer/Player.java

@@ -0,0 +1,178 @@
+package com.fgodt.mixplayer;
+
+import android.content.Context;
+
+import java.util.ArrayList;
+
+
+/**
+ * Created by rt-zl on 2019/2/15.
+ */
+
+public class Player extends Render {
+
+
+    public final int STATUS_ERROR = 0;
+    public final int STATUS_STOP = 1;
+    public final int STATUS_START = 2;
+    public final int STATUS_PAUSE = 3;
+    public final int STATUS_BUFFING = 4;
+    public final int STATUS_RUNNING = 5;
+
+    private Core mixCore;
+    private Core enMixCore;
+    private String url ;
+    private mixPlayerCallBack callBack;
+    private boolean needSelectAudioSource = false;
+
+    public Player(Context context){
+        super(context);
+    }
+
+    ArrayList<mixSource> mixSourceName = new ArrayList<mixSource>();
+    private void addMixList(){
+        if(mixCore == null){
+            return;
+        }
+        for (mixSource source :mixSourceName){
+            mixCore.addMixSource(source.name, source.startTime, source.duration);
+        }
+    }
+
+    private void selectAudioSource(){
+        if(mixCore == null){
+            return;
+        }
+        for (mixSource source :mixSourceName){
+            if(source.select){
+                mixCore.selectAudioSource(source.name);
+            }
+        }
+    }
+
+    private void createCore(){
+        if(mixCore != null){
+            mixCore.mixClose();
+            this.renderClose();
+        }
+        mixCore = new Core();
+        mixCore.init(this);
+        mixCore.setMixCall(callBack);
+        addMixList();
+        if(needSelectAudioSource){
+            selectAudioSource();
+        }
+    }
+
+    private void createEnCore(){
+        if(enMixCore != null){
+            enMixCore.mixClose();
+        }
+        enMixCore = new Core();
+    }
+
+    public void open(String url){
+        createCore();
+        this.url = url;
+        mixCore.setUrl(url);
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                mixCore.open();
+            }
+        }).start();
+    }
+
+
+    public void resume(){
+        if(mixCore!=null){
+            mixCore.resume();
+        }
+        ispause = false;
+    }
+    public void stop(){
+        if(mixCore!=null){
+            mixCore.mixClose();
+            this.renderClose();
+        }
+    }
+    public void pause(){
+        if(mixCore!=null){
+            mixCore.pause();
+        }
+        ispause = true;
+    }
+    public void seek(double time){
+        if(mixCore != null){
+            mixCore.seek(time);
+        }
+    }
+    public void setMixCall(mixPlayerCallBack call){
+        this.callBack = call;
+    }
+    public double getDuration(){
+        if(mixCore!=null){
+            return mixCore.mixGetDuration();
+        }
+        return -1;
+    }
+    public double getPlayTime(){
+        double time = super.getPlaytime();
+        return time;
+    }
+
+    public double getSaveTime(){
+        return -1;
+    }
+
+    public void addMixSource(String name ,double stime, double duration){
+        mixSource source = new mixSource();
+        source.name = name;
+        source.startTime = stime;
+        source.duration = duration;
+        source.select  = false;
+        mixSourceName.add(source);
+    }
+
+    public void saveFile(String input, String output){
+        createCore();
+        this.url = input;
+        mixCore.setUrl(url);
+        mixCore.setSavePath(output);
+        mixCore.save();
+    }
+
+    public void selectAudioSource(String name){
+        needSelectAudioSource = true;
+        for(mixSource source : mixSourceName){
+            if(source.name.equals(name)){
+                source.select = true;
+            }
+        }
+    }
+
+    public int getStatus(){
+        if(mixCore != null){
+            return  mixCore.getStatus();
+        }
+        return STATUS_STOP;
+    }
+
+    public void setVolume(float volume){
+        this.volume = volume;
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+        if(mixCore!= null)
+            mixCore.mixClose();
+    }
+
+    class mixSource{
+        public String name;
+        public double startTime;
+        public double duration;
+        public boolean select;
+    }
+}

android/src/main/java/com/fgodt/mixplayer/Render.java

@@ -0,0 +1,187 @@
+package com.fgodt.mixplayer;
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.media.AudioAttributes;
+import android.media.AudioFormat;
+import android.media.AudioManager;
+import android.media.AudioTrack;
+import android.opengl.GLSurfaceView;
+import android.support.v7.app.AppCompatActivity;
+import android.util.Log;
+import android.widget.FrameLayout;
+
+import java.sql.Time;
+import java.util.Arrays;
+import java.util.Date;
+
+import static java.lang.Thread.*;
+
+/**
+ * Created by rt-zl on 2019/2/15.
+ */
+
+public class Render extends VideoRender {
+
+
+
+    static {
+        System.loadLibrary("mixplayer");
+    }
+
+    private long handler = 0;
+
+    private native int setRenderHandler(long handler);
+
+    int asample, ach, abit;
+    public int mixUpdateAudio(byte[] data, int size,double pts){
+        playTime = pts;
+        synchronized (audioBuf) {
+            if (audioBufLen - audioHas < size) {
+                return -1;
+            }
+            int len = audioBufLen - audioWPos;
+            len = len > size ? size :len;
+            System.arraycopy(data,0,audioBuf,audioWPos,len);
+            audioWPos += len;
+            audioHas +=len;
+            if(audioWPos == audioBufLen){
+                audioWPos = 0;
+            }
+            if(len<size){
+                int les = size - len;
+                System.arraycopy(data,len,audioBuf,audioWPos,les);
+                audioWPos +=les;
+                audioHas += les;
+            }
+            return 0;
+        }
+    }
+
+
+    public int mixOpen(int vWidth,int vHeight,int asample, int ach, int abit){
+        if(vWidth>0){
+            Log.d("MIXOPEN","has video");
+            nativeInit(getScreenWidth(),getScreenHeight());
+            this.abit = abit;
+            this.asample = asample;
+            this.ach = ach;
+            initAudioTrack();
+            return  0;
+        }
+        return -1;
+    }
+
+
+    public void mixClose(){
+        super.close();
+    }
+
+    public void renderClose(){
+        play = false;
+        if (audioTrack!=null){
+            audioTrack.stop();
+            totalAudioBuf = 0;
+        }
+    }
+
+    public Render(Context context){
+        super(context);
+    }
+
+    public void init(long handler){
+        this.handler = handler;
+        setMixHander(handler);
+        this.setRenderHandler(handler);
+    }
+
+    public double getPlaytime() {
+        return  playTime;
+    }
+
+    AudioTrack audioTrack ;
+
+    byte[] audioBuf ;
+    long totalAudioBuf;
+    int audioHas;
+    int audioRPos, audioWPos;
+    int audioBufLen = 4096*3;
+    long silenceLen = 0;
+    boolean play = false;
+    double playTime = 0;
+    byte[] silencBuf;
+    private void initAudioTrack(){
+        silencBuf = new byte[4096];
+        audioBuf = new byte[audioBufLen];
+        audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,asample,
+                AudioFormat.CHANNEL_IN_STEREO,AudioFormat.ENCODING_PCM_16BIT,audioBufLen,AudioTrack.MODE_STREAM);
+        play = true;
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                int wsize = 1024;
+                long posPre = 0;
+                boolean needUpdate = false;
+                int retryCount = 0;
+                while (play) {
+                    synchronized (audioBuf) {
+                        long pos = audioTrack.getPlaybackHeadPosition();
+                        // 16bit 2channels = 4 Byte
+                        pos *= 4;
+                        pos -= silenceLen;
+                        if(posPre != pos){
+                            posPre = pos;
+                            retryCount = 0;
+                        }else {
+                            if(retryCount > 5)
+                                needUpdate = true;
+                            retryCount ++;
+                        }
+                        if (audioHas >= wsize && totalAudioBuf - pos < audioBufLen || pos <= 0 ||needUpdate ) {
+                            needUpdate = false;
+                            int len = audioBufLen - audioRPos;
+                            len = len > wsize? wsize:len;
+                            int ret = audioTrack.write(audioBuf, audioRPos, len);
+                            audioRPos += ret;
+                            audioHas -= ret;
+                            totalAudioBuf+=ret;
+                            if (audioRPos == audioBufLen) {
+                                audioRPos = 0;
+                            }
+                        }else {
+                        //    if (pos == totalAudioBuf && audioHas < wsize){
+                        //        int c = audioTrack.write(silencBuf,0,2048);
+                        //        silenceLen +=c;
+                        //    }
+                        }
+                        if(ispause){
+                            if(audioTrack.getPlayState() != AudioTrack.PLAYSTATE_PAUSED) {
+                                audioTrack.pause();
+                                audioTrack.setVolume(0);
+                            }
+                        }else{
+                            if(audioTrack.getPlayState()!=AudioTrack.PLAYSTATE_PLAYING) {
+                                audioTrack.play();
+                                audioTrack.setVolume(volume);
+                            }
+                        }
+                    }
+                    try {
+                        sleep(3);
+                    }catch (Exception ex){
+                    }
+                }
+                Log.d("mixplayer","audio close");
+            }
+        }).start();
+        audioTrack.play();
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+        play = false;
+        renderClose();
+    }
+
+}

android/src/main/java/com/fgodt/mixplayer/VideoRender.java

@@ -0,0 +1,93 @@
+package com.fgodt.mixplayer;
+
+
+
+import android.content.Context;
+import android.opengl.GLES20;
+import android.opengl.GLSurfaceView;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+public class VideoRender extends GLSurfaceView implements GLSurfaceView.Renderer {
+
+    //lib mixplayer hander
+    private long  hander = 0;
+    private int mScreenWidth, mScreenHeight;
+    private native void step(long handler);
+    private native void init(long handler,int w, int h);
+    private native void nativeChangeSize(long handler, int w, int h);
+
+    final Object textLocker = new Object();
+
+    boolean ispause = false;
+    float volume = 1.0f;
+
+
+    private boolean createDone=false;
+
+    public VideoRender(Context context){
+        super(context);
+        this.setEGLContextClientVersion(2);
+        this.setRenderer(this);
+    }
+    public int getScreenWidth(){
+        return mScreenWidth;
+    }
+    public int getScreenHeight(){
+        return mScreenHeight;
+    }
+
+
+    boolean inited = false;
+    boolean hasrender = false;
+    void nativeInit(int w, int h){
+        hasrender = true;
+    }
+    void nativeStep(){
+        if(hasrender && !inited){
+            init(hander,getScreenWidth(),getScreenHeight());
+            inited = true;
+        }
+        if(hander>0 && inited){
+            step(hander);
+        }
+    }
+
+    void close(){
+        hander = 0;
+        inited = false;
+        hasrender = false;
+    }
+
+
+    public void setMixHander(long hander){
+        this.hander = hander;
+    }
+
+    @Override
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+        return;
+    }
+
+    @Override
+    public void onSurfaceChanged(GL10 gl, int width, int height) {
+        mScreenWidth =width;
+        mScreenHeight = height;
+        if(this.hander>0){
+            nativeChangeSize(this.hander,width,height);
+        }
+        return;
+    }
+
+
+    @Override
+    public void onDrawFrame(GL10 gl) {
+        if(hander == 0){
+            GLES20.glClearColor(0,0,0,1);
+            GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
+        }
+        nativeStep();
+        return;
+    }
+}

android/src/main/java/com/fgodt/mixplayer/mixPlayerCallBack.java

@@ -0,0 +1,6 @@
+package com.fgodt.mixplayer;
+
+public interface mixPlayerCallBack{
+    public int mix_call(String name, byte[] data, int len);
+    public void closeMsg(String msg);
+}

android/src/main/java/com/fogdt/mixsample/MainActivity.java

@@ -0,0 +1,252 @@
+package com.fogdt.mixsample;
+
+import android.Manifest;
+import android.app.ActivityManager;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.media.AudioFormat;
+import android.media.AudioRecord;
+import android.media.MediaCodecInfo;
+import android.media.MediaRecorder;
+import android.os.Environment;
+import android.os.PersistableBundle;
+import android.support.annotation.Nullable;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.content.ContextCompat;
+import android.support.v7.app.AppCompatActivity;
+import android.os.Bundle;
+import android.text.TextPaint;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowManager;
+import android.widget.EditText;
+import android.widget.FrameLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.fgodt.mixplayer.Core;
+import com.fgodt.mixplayer.Player;
+import com.fgodt.mixplayer.mixPlayerCallBack;
+
+import java.io.File;
+
+
+public class MainActivity extends AppCompatActivity implements mixPlayerCallBack {
+
+
+    private long handler =0;
+
+    AudioRecord audioRecord = null;
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+
+
+        setContentView(R.layout.activity_main);
+
+
+
+        // Example of a call to a native method
+        TextView tv = (TextView) findViewById(R.id.sample_text);
+
+        tv.setText("el");
+        getPermission();
+
+
+        if(savedInstanceState == null)
+            test();
+    }
+
+    @Override
+    public void onWindowAttributesChanged(WindowManager.LayoutParams params) {
+        super.onWindowAttributesChanged(params);
+    }
+
+    private Player mixplayer ;
+    private void test(){
+
+        FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.FILL_PARENT,
+                FrameLayout.LayoutParams.WRAP_CONTENT);
+        params.gravity = Gravity.TOP;
+        params.height = 1080*9/16;
+        mixplayer = new Player(this);
+        mixplayer.setMixCall(this);
+        mixplayer.addMixSource("mix1",0,-1);
+        mixplayer.addMixSource("silence",0,-1);
+       // mixplayer.selectAudioSource("silence");
+       // mixplayer.selectAudioSource("mix1");
+        addContentView(mixplayer,params);
+        editText = findViewById(R.id.editText);
+    }
+
+    private String getPath(){
+        String  file = Environment.getExternalStoragePublicDirectory(
+                Environment.DIRECTORY_MOVIES)+"" ;
+        return file;
+    }
+
+    private EditText editText;
+    public void playClick(View sender){
+        if(!hasRWPermission) {
+            getPermission();
+            return;
+        }
+        mixplayer.open(editText.getText().toString());
+    }
+
+    public void savedClick(View view){
+        //mixplayer.selectAudioSource(editText.getText().toString());
+        mixplayer.saveFile(editText.getText().toString(),getPath()+"/mixtest.mp4");
+        //mixplayer.saveFile(editText.getText().toString(),"rtmp://192.168.3.10/live/abc1234");
+    }
+
+    //10s pcm data
+    int totalLen = 4*44100*10;
+    byte[] pcmData = new byte[4*44100*10];
+    int pcmWritePos = 0;
+    public void closeClick(View sender){
+       mixplayer.stop();
+    }
+
+    public void recorderClick(View view){
+        if(!hasRcordPermission) {
+            getPermission();
+            return;
+        }
+
+
+        audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC,44100, AudioFormat.CHANNEL_IN_STEREO,AudioFormat.ENCODING_PCM_16BIT,4096*3);
+        if(audioRecord.getState() != AudioRecord.STATE_INITIALIZED){
+            Toast.makeText(this,"初始化录音失败",Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        if(audioRecord != null){
+            audioRecord.startRecording();
+            pcmWritePos = 0;
+            pcmReadPos = 0;
+            new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    while (pcmWritePos<totalLen){
+                        int wlen = totalLen-pcmWritePos > 4096? 4096:totalLen-pcmWritePos;
+                        int ret = audioRecord.read(pcmData,pcmWritePos,wlen);
+                        pcmWritePos+=ret;
+                    }
+                    audioRecord.stop();
+                }
+            }).start();
+        }
+    }
+
+    public void playerAndResume(View view){
+        if(mixplayer.getStatus() == mixplayer.STATUS_PAUSE){
+            mixplayer.resume();
+        }else if(mixplayer.getStatus() == mixplayer.STATUS_RUNNING){
+            mixplayer.pause();
+        }
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+    }
+
+
+    @Override
+    protected void onRestoreInstanceState(Bundle savedInstanceState) {
+        super.onRestoreInstanceState(savedInstanceState);
+    }
+
+
+    int pcmReadPos = 0;
+    @Override
+    public int mix_call(String name, byte[] data, int len) {
+        if(name.equals("silence")){
+            return 0;
+        }
+        if(totalLen - pcmReadPos < len){
+            return 0;
+        }else {
+            System.arraycopy(pcmData,pcmReadPos,data,0,len);
+            pcmReadPos += len;
+            return len;
+        }
+    }
+
+    @Override
+    public void closeMsg(String msg) {
+        Toast.makeText(this,"MIX CLOSE",Toast.LENGTH_SHORT).show();
+    }
+
+
+    private boolean hasRWPermission = false;
+    private boolean hasRcordPermission = false;
+
+    private  void getPermission(){
+        int has = ContextCompat.checkSelfPermission(getApplication(), Manifest.permission.WRITE_EXTERNAL_STORAGE);
+        if (has == PackageManager.PERMISSION_GRANTED){
+            hasRWPermission = true;
+        }else {
+            ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE  },1);
+        }
+
+        has = ContextCompat.checkSelfPermission(getApplication(), Manifest.permission.RECORD_AUDIO);
+        if (has == PackageManager.PERMISSION_GRANTED){
+            hasRcordPermission = true;
+        }else {
+            ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.RECORD_AUDIO},2);
+        }
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults){
+        if(requestCode == 1){
+            if(grantResults.length>0&&grantResults[0] == PackageManager.PERMISSION_GRANTED){
+                hasRWPermission = true;
+            }else {
+                if(ActivityCompat.shouldShowRequestPermissionRationale(this,Manifest.permission.WRITE_EXTERNAL_STORAGE)){
+                    new AlertDialog.Builder(this)
+                            .setMessage("need read write permisson")
+                            .setPositiveButton("ok",(d,w)->{
+                                if (w == DialogInterface.BUTTON_POSITIVE){
+                                    ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},1);
+                                }
+                            })
+                            .setNegativeButton("cancle",null)
+                            .setTitle("需要提供相应权限")
+                            .create()
+                            .show();
+                }
+            }
+        }
+        if (requestCode == 2){
+            if(grantResults.length>0&&grantResults[0] == PackageManager.PERMISSION_GRANTED){
+                hasRcordPermission = true;
+            }else {
+                if(ActivityCompat.shouldShowRequestPermissionRationale(this,Manifest.permission.RECORD_AUDIO)){
+                    new AlertDialog.Builder(this)
+                            .setMessage("need record audio permisson")
+                            .setPositiveButton("ok",(dialog,which)->{
+                                if (which == DialogInterface.BUTTON_POSITIVE){
+                                    ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.RECORD_AUDIO},1);
+                                }
+                            })
+                            .setNegativeButton("cancle",null)
+                            .setTitle("需要录音权限")
+                            .create()
+                            .show();
+                }
+            }
+        }
+    }
+
+}