FFmpegRecordActivity [vs1]

package com.soialab.askaruly.camera_sensor;

import android.Manifest;
import android.app.ProgressDialog;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.ActivityNotFoundException;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.graphics.SurfaceTexture;
import android.hardware.Camera;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Handler;
import android.support.annotation.NonNull;
import android.support.annotation.RequiresApi;
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.TextUtils;
import android.text.method.ScrollingMovementMethod;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.widget.Button;
import android.widget.CompoundButton;
import android.widget.EditText;
import android.widget.GridLayout;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.ScrollView;
import android.widget.Switch;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.ToggleButton;

import com.github.mikephil.charting.charts.LineChart;
import com.github.mikephil.charting.components.Legend;
import com.github.mikephil.charting.components.XAxis;
import com.github.mikephil.charting.components.YAxis;
import com.github.mikephil.charting.data.Entry;
import com.github.mikephil.charting.data.LineData;
import com.github.mikephil.charting.data.LineDataSet;
import com.github.mikephil.charting.utils.ColorTemplate;

import org.bytedeco.javacpp.avcodec;
import org.bytedeco.javacpp.avutil;
import org.bytedeco.javacv.FFmpegFrameFilter;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import org.bytedeco.javacv.Frame;
import org.bytedeco.javacv.FrameFilter;
import org.w3c.dom.Text;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.ByteBuffer;
import java.nio.ShortBuffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingQueue;
import java.nio.file.Path;
import java.nio.file.Files;
import de.siegmar.fastcsv.writer.CsvAppender;
import de.siegmar.fastcsv.writer.CsvWriter;
import me.aflak.bluetooth.Bluetooth;

import static java.lang.Thread.State.WAITING;

public class FFmpegRecordActivity extends AppCompatActivity implements
        TextureView.SurfaceTextureListener, View.OnClickListener, Bluetooth.CommunicationCallback {

    private static final String LOG_TAG = FFmpegRecordActivity.class.getSimpleName();

    private static final int REQUEST_PERMISSIONS = 1;

    private static final int PREFERRED_PREVIEW_WIDTH = 640;
    private static final int PREFERRED_PREVIEW_HEIGHT = 480;

    // both in milliseconds
    private static final long MIN_VIDEO_LENGTH = 1 * 1000;
    private static final long MAX_VIDEO_LENGTH = 90 * 1000;

    private FixedRatioCroppedTextureView mPreview;
    private Button mBtnResumeOrPause;
    private Button mBtnDone;
    private Button mBtnSwitchCamera;
    private Button mBtnReset;

    private int mCameraId;
    private Camera mCamera;
    private FFmpegFrameRecorder mFrameRecorder;
    private VideoRecordThread mVideoRecordThread;
    private AudioRecordThread mAudioRecordThread;
    private volatile boolean mRecording = false;
    private File mVideo;
    private File mText;
    private LinkedBlockingQueue<FrameToRecord> mFrameToRecordQueue;
    private LinkedBlockingQueue<FrameToRecord> mRecycledFrameQueue;
    private int mFrameToRecordCount;
    private int mFrameRecordedCount;
    private long mTotalProcessFrameTime;
    private Stack<RecordFragment> mRecordFragments;


    private int sampleAudioRateInHz = 44100;
    /* The sides of width and height are based on camera orientation.
    That is, the preview size is the size before it is rotated. */
    private int mPreviewWidth = PREFERRED_PREVIEW_WIDTH;
    private int mPreviewHeight = PREFERRED_PREVIEW_HEIGHT;
    // Output video size
    private int videoWidth = 320;
    private int videoHeight = 240;
    private int frameRate = 30;
    private int frameDepth = Frame.DEPTH_UBYTE;
    private int frameChannels = 2;

    // Workaround for https://code.google.com/p/android/issues/detail?id=190966
    private Runnable doAfterAllPermissionsGranted;

    ///////////////////////////////////////////////////////////////////////////////////////
    private String name;
    private Bluetooth b;
    private EditText message;
    private Button send;
    private TextView text;
    private ScrollView scrollView;
    private boolean registered=false;
    ///////////////////////////////////////////////////////////////////////////////////////
    private boolean resumeBtnPressed = false;
    private FileWriter writer;
    private CsvWriter csvWriter;

    // Sensor display
    private TextView timeinfo;
    private TextView hrinfo;
    private TextView oxinfo;
    private TextView tenoinfo;
    private TextView audioInfo;
    private TextView stretchInfo;

    // Accelerometer
    private TextView yawInfo;
    private TextView pitchInfo;
    private TextView rollInfo;

    // Int for writing header
    private boolean sensorHeaderCheck = false;
    private int sensorValueIndex = 0;

    private float hrTtl = 0;
    private float oxTtl = 0;
    private float tempTtl = 0;
    private float audioTtl = 0;
    private float stretchTtl = 0;
    private float yawTtl = 0;
    private float pitchTtl = 0;
    private float rollTtl = 0;

    private int sensValCount = 0;

    // Plotting variables
    private RelativeLayout mainLayout;
    private LineChart mChart1;
    //private LineChart mChart2;

    private Switch modeSwitch;

    //
    RelativeLayout linechartLayout;
    GridLayout sensorsGridLayout;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_ffmpeg_record);

        //
        mPreview = (FixedRatioCroppedTextureView) findViewById(R.id.camera_preview);
        mBtnResumeOrPause = (Button) findViewById(R.id.btn_resume_or_pause);
        mBtnDone = (Button) findViewById(R.id.btn_done);
        mBtnSwitchCamera = (Button) findViewById(R.id.btn_switch_camera);
        mBtnReset = (Button) findViewById(R.id.btn_reset);



//        mCameraId = Camera.CameraInfo.CAMERA_FACING_BACK;
        mCameraId = Camera.CameraInfo.CAMERA_FACING_FRONT;
        setPreviewSize(mPreviewWidth, mPreviewHeight);
        mPreview.setCroppedSizeWeight(videoWidth, videoHeight);
        mPreview.setSurfaceTextureListener(this);
        mBtnResumeOrPause.setOnClickListener(this);
        mBtnDone.setOnClickListener(this);
        mBtnSwitchCamera.setOnClickListener(this);
        mBtnReset.setOnClickListener(this);

        // At most buffer 10 Frame
        mFrameToRecordQueue = new LinkedBlockingQueue<>(10);
        // At most recycle 2 Frame
        mRecycledFrameQueue = new LinkedBlockingQueue<>(2);
        mRecordFragments = new Stack<>();

        //Creating new CSV File:
        // Toggle Button
        modeSwitch = (Switch)  findViewById(R.id.model_switch);


        /////////////////////////////////////////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////////////////////////////////////////
        //timeinfo = (TextView)findViewById(R.id.charger);

        timeinfo = (TextView)findViewById(R.id.timeStat);
        hrinfo = (TextView)findViewById(R.id.hrStat);;
        oxinfo = (TextView)findViewById(R.id.oxStat);;
        tenoinfo = (TextView)findViewById(R.id.tempStat);;
        audioInfo = (TextView)findViewById(R.id.audioStat);
        stretchInfo = (TextView)findViewById(R.id.stretchStat);

        // Declaring ypr texts
        yawInfo = (TextView)findViewById(R.id.yawStat);
        pitchInfo = (TextView)findViewById(R.id.pitchStat);
        rollInfo = (TextView)findViewById(R.id.rollStat);
        //

        text = (TextView)findViewById(R.id.text);
        //message = (EditText)findViewById(R.id.message);       //This is a message sending window
        send = (Button)findViewById(R.id.send);
        scrollView = (ScrollView) findViewById(R.id.scrollView);

        text.setMovementMethod(new ScrollingMovementMethod());
        ////////////////////////////////////////////////////////////////////////////////////////////
        send.setEnabled(false);
        ////////////////////////////////////////////////////////////////////////////////////////////
        b = new Bluetooth(this);
        b.enableBluetooth();

        b.setCommunicationCallback(this);

        int pos = getIntent().getExtras().getInt("pos");
        name = b.getPairedDevices().get(pos).getName();

        Display("Connecting...");
        b.connectToDevice(b.getPairedDevices().get(pos));

        send.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
            b.send("s");
                /*
            String msg = message.getText().toString();
            message.setText("");
            b.send(msg);
            Display("You: "+msg);
            */
            }
        });

        IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
        registerReceiver(mReceiver, filter);
        registered=true;

        // Working with visualization charts

        mChart1 = (LineChart) findViewById(R.id.mChart1);
        mChart1.setDescription("");
        mChart1.setNoDataTextDescription("No data for the moment");

        mChart1.setHighlightEnabled(true); ///////////////////////////////////

        //enable touch gestures
        mChart1.setTouchEnabled(true);

        // enable scaling and dragging
        mChart1.setDragEnabled(true);
        mChart1.setScaleEnabled(true);
        mChart1.setDrawGridBackground(false);

        // enable pinch zoom to avoid x and y axis separately
        mChart1.setPinchZoom(true);

        // alternative background color
        mChart1.setBackgroundColor(Color.LTGRAY);

        // now work on data
        LineData data1 = new LineData();
        data1.setValueTextColor(Color.WHITE);

        // add data to line chart
        mChart1.setData(data1);

        // get legend object
        Legend l = mChart1.getLegend();

        //customize legend
        l.setForm(Legend.LegendForm.LINE);
        l.setTextColor(Color.WHITE);

        XAxis x1 = mChart1.getXAxis();
        x1.setTextColor(Color.WHITE);
        x1.setDrawGridLines(false);
        x1.setAvoidFirstLastClipping(true);

        YAxis y1 = mChart1.getAxisLeft();
        y1.setTextColor(Color.WHITE);
        y1.setAxisMaxValue(120f);  ///////////////////////////////////
//        y1.setStartAtZero(true);
        y1.setDrawGridLines(true);

        YAxis y12 = mChart1.getAxisRight();
        y12.setEnabled(false);



        ////// Toggle Button Switch
        linechartLayout = (RelativeLayout)findViewById(R.id.linechartLayout);
        sensorsGridLayout = (GridLayout)findViewById(R.id.sensorsGridLayout);



        modeSwitch.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {



            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                if (isChecked) {
                    // do something when checked is selected
                    linechartLayout.setVisibility(RelativeLayout.INVISIBLE);
                    sensorsGridLayout.setVisibility(GridLayout.VISIBLE);
                } else {
                    //do something when unchecked
                    linechartLayout.setVisibility(RelativeLayout.VISIBLE);
                    sensorsGridLayout.setVisibility(GridLayout.INVISIBLE);
                }
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        stopRecorder();
        releaseRecorder(true);
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        if(registered) {
            unregisterReceiver(mReceiver);
            registered=false;
        }
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        try {
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    }

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

        if (doAfterAllPermissionsGranted != null) {
            doAfterAllPermissionsGranted.run();
            doAfterAllPermissionsGranted = null;
        } else {
            String[] neededPermissions = {
                    Manifest.permission.CAMERA,
                    Manifest.permission.RECORD_AUDIO,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE,
            };
            List<String> deniedPermissions = new ArrayList<>();
            for (String permission : neededPermissions) {
                if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
                    deniedPermissions.add(permission);
                }
            }
            if (deniedPermissions.isEmpty()) {
                // All permissions are granted
                doAfterAllPermissionsGranted();
            } else {
                String[] array = new String[deniedPermissions.size()];
                array = deniedPermissions.toArray(array);
                ActivityCompat.requestPermissions(this, array, REQUEST_PERMISSIONS);
            }
        }


    }

    @Override
    protected void onPause() {
        super.onPause();
        pauseRecording();
        stopRecording();
        stopPreview();
        releaseCamera();
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == REQUEST_PERMISSIONS) {
            boolean permissionsAllGranted = true;
            for (int grantResult : grantResults) {
                if (grantResult != PackageManager.PERMISSION_GRANTED) {
                    permissionsAllGranted = false;
                    break;
                }
            }
            if (permissionsAllGranted) {
                doAfterAllPermissionsGranted = new Runnable() {
                    @Override
                    public void run() {
                        doAfterAllPermissionsGranted();
                    }
                };
            } else {
                doAfterAllPermissionsGranted = new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(FFmpegRecordActivity.this, R.string.permissions_denied_exit, Toast.LENGTH_SHORT).show();
                        finish();
                    }
                };
            }
        }
    }

    @Override
    public void onSurfaceTextureAvailable(final SurfaceTexture surface, int width, int height1) {
        startPreview(surface);
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        return true;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
    }

    @Override
    public void onClick(View v) {
        int i = v.getId();
        if (i == R.id.btn_resume_or_pause) {
            if (mRecording) {
                pauseRecording();
            } else {
                resumeRecording();
                ////////////////////////////////////////////////////////////////////////////////////////////////
            }

        } else if (i == R.id.btn_done) {
            pauseRecording();
            // check video length
            if (calculateTotalRecordedTime(mRecordFragments) < MIN_VIDEO_LENGTH) {
                Toast.makeText(this, R.string.video_too_short, Toast.LENGTH_SHORT).show();
                return;
            }
            new FinishRecordingTask().execute();

        } else if (i == R.id.btn_switch_camera) {
            final SurfaceTexture surfaceTexture = mPreview.getSurfaceTexture();
            new ProgressDialogTask<Void, Integer, Void>(R.string.please_wait) {

                @Override
                protected Void doInBackground(Void... params) {
                    stopRecording();
                    stopPreview();
                    releaseCamera();

                    mCameraId = (mCameraId + 1) % 2;

                    acquireCamera();
                    startPreview(surfaceTexture);
                    startRecording();
                    return null;
                }
            }.execute();

        } else if (i == R.id.btn_reset) {
            pauseRecording();
            new ProgressDialogTask<Void, Integer, Void>(R.string.please_wait) {

                @Override
                protected Void doInBackground(Void... params) {
                    stopRecording();
                    stopRecorder();

                    startRecorder();
                    startRecording();
                    ////////////////////////////////////////////////////////////////////////////////////////////////

                    return null;
                }
            }.execute();
        }
    }


    private void doAfterAllPermissionsGranted() {
        acquireCamera();
        SurfaceTexture surfaceTexture = mPreview.getSurfaceTexture();
        if (surfaceTexture != null) {
            // SurfaceTexture already created
            startPreview(surfaceTexture);
        }
        new ProgressDialogTask<Void, Integer, Void>(R.string.initiating) {

            @Override
            protected Void doInBackground(Void... params) {
                if (mFrameRecorder == null) {
                    try {
                        initRecorder();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    startRecorder();
                }
                startRecording();
                return null;
            }
        }.execute();
    }

    private void setPreviewSize(int width, int height) {
        if (MiscUtils.isOrientationLandscape(this)) {
            mPreview.setPreviewSize(width, height);
        } else {
            // Swap width and height
            mPreview.setPreviewSize(height, width);
        }
    }

    private void startPreview(SurfaceTexture surfaceTexture) {
        if (mCamera == null) {
            return;
        }

        Camera.Parameters parameters = mCamera.getParameters();
        List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes();
        Camera.Size previewSize = CameraHelper.getOptimalSize(previewSizes,
                PREFERRED_PREVIEW_WIDTH, PREFERRED_PREVIEW_HEIGHT);
        // if changed, reassign values and request layout
        if (mPreviewWidth != previewSize.width || mPreviewHeight != previewSize.height) {
            mPreviewWidth = previewSize.width;
            mPreviewHeight = previewSize.height;
            setPreviewSize(mPreviewWidth, mPreviewHeight);
            mPreview.requestLayout();
        }
        parameters.setPreviewSize(mPreviewWidth, mPreviewHeight);
//        parameters.setPreviewFormat(ImageFormat.NV21);
        mCamera.setParameters(parameters);

        mCamera.setDisplayOrientation(CameraHelper.getCameraDisplayOrientation(
                this, mCameraId));

        // YCbCr_420_SP (NV21) format
        byte[] bufferByte = new byte[mPreviewWidth * mPreviewHeight * 3 / 2];
        mCamera.addCallbackBuffer(bufferByte);
        mCamera.setPreviewCallbackWithBuffer(new Camera.PreviewCallback() {

            private long lastPreviewFrameTime;

            @Override
            public void onPreviewFrame(byte[] data, Camera camera) {
                long thisPreviewFrameTime = System.currentTimeMillis();
                if (lastPreviewFrameTime > 0) {
                    Log.d(LOG_TAG, "Preview frame interval: " + (thisPreviewFrameTime - lastPreviewFrameTime) + "ms");
                }
                lastPreviewFrameTime = thisPreviewFrameTime;

                // get video data
                if (mRecording) {
                    if (mAudioRecordThread == null || !mAudioRecordThread.isRunning()) {
                        // wait for AudioRecord to init and start
                        mRecordFragments.peek().setStartTimestamp(System.currentTimeMillis());
                    } else {
                        // pop the current record fragment when calculate total recorded time
                        RecordFragment curFragment = mRecordFragments.pop();
                        long recordedTime = calculateTotalRecordedTime(mRecordFragments);
                        // push it back after calculation
                        mRecordFragments.push(curFragment);
                        long curRecordedTime = System.currentTimeMillis()
                                - curFragment.getStartTimestamp() + recordedTime;
                        // check if exceeds time limit
                        if (curRecordedTime > MAX_VIDEO_LENGTH) {
                            pauseRecording();
                            new FinishRecordingTask().execute();
                            return;
                        }

                        long timestamp = 1000 * curRecordedTime;
                        Frame frame;
                        FrameToRecord frameToRecord = mRecycledFrameQueue.poll();
                        if (frameToRecord != null) {
                            frame = frameToRecord.getFrame();
                            frameToRecord.setTimestamp(timestamp);
                        } else {
                            frame = new Frame(mPreviewWidth, mPreviewHeight, frameDepth, frameChannels);
                            frameToRecord = new FrameToRecord(timestamp, frame);
                        }
                        ((ByteBuffer) frame.image[0].position(0)).put(data);

                        if (mFrameToRecordQueue.offer(frameToRecord)) {
                            mFrameToRecordCount++;
                        }
                    }
                }
                mCamera.addCallbackBuffer(data);
            }
        });

        try {
            mCamera.setPreviewTexture(surfaceTexture);
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
        mCamera.startPreview();
    }

    private void stopPreview() {
        if (mCamera != null) {
            mCamera.stopPreview();
            mCamera.setPreviewCallbackWithBuffer(null);
        }
    }

    private void acquireCamera() {
        try {
            mCamera = Camera.open(mCameraId);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void releaseCamera() {
        if (mCamera != null) {
            mCamera.release();        // release the camera for other applications
            mCamera = null;
        }
    }

    private void initRecorder() throws IOException {
        Log.i(LOG_TAG, "init mFrameRecorder");

        String recordedTime = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
        mVideo = CameraHelper.getOutputMediaFile(recordedTime, CameraHelper.MEDIA_TYPE_VIDEO);
        mText = CameraHelper.getOutputMediaFile(recordedTime, CameraHelper.MEDIA_TYPE_TEXT);
        ////////////////////////////////////////////////////////////////////////////////////////////////


       try {
            writer = new FileWriter(mText);
            /*
            writer.append("ID");
            writer.append(",");
            writer.append("Time");
            writer.append(",");
            writer.append("HR");
            writer.append(",");
            writer.append("Ox Rate");
            writer.append(",");
            writer.append("Temp");
            writer.append("\n");
            writer.flush();
            */
            sensorHeaderCheck = true;
        } catch (IOException e) {
            e.printStackTrace();
        }

        Log.i(LOG_TAG, "Output Video: " + mVideo);
        Log.i(LOG_TAG, "Output Text: " + mText);

        mFrameRecorder = new FFmpegFrameRecorder(mVideo, videoWidth, videoHeight, 1);
        mFrameRecorder.setFormat("mp4");
        mFrameRecorder.setSampleRate(sampleAudioRateInHz);
        mFrameRecorder.setFrameRate(frameRate);
        // Use H264
        mFrameRecorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);

        // See: https://trac.ffmpeg.org/wiki/Encode/H.264#crf
        /*
         * The range of the quantizer scale is 0-51: where 0 is lossless, 23 is default, and 51 is worst possible. A lower value is a higher quality and a subjectively sane range is 18-28. Consider 18 to be visually lossless or nearly so: it should look the same or nearly the same as the input but it isn't technically lossless.
         * The range is exponential, so increasing the CRF value +6 is roughly half the bitrate while -6 is roughly twice the bitrate. General usage is to choose the highest CRF value that still provides an acceptable quality. If the output looks good, then try a higher value and if it looks bad then choose a lower value.
         */
        mFrameRecorder.setVideoOption("crf", "28");
        mFrameRecorder.setVideoOption("preset", "superfast");
        mFrameRecorder.setVideoOption("tune", "zerolatency");

        Log.i(LOG_TAG, "mFrameRecorder initialize success");
    }

    private void releaseRecorder(boolean deleteFile) {
        if (mFrameRecorder != null) {
            try {
                mFrameRecorder.release();
            } catch (FFmpegFrameRecorder.Exception e) {
                e.printStackTrace();
            }
            mFrameRecorder = null;

            if (deleteFile) {
                mVideo.delete();
                mText.delete();
            }
        }
    }

    private void startRecorder() {
        try {
            mFrameRecorder.start();
        } catch (FFmpegFrameRecorder.Exception e) {
            e.printStackTrace();
        }
    }

    private void stopRecorder() {
        if (mFrameRecorder != null) {
            try {
                mFrameRecorder.stop();
            } catch (FFmpegFrameRecorder.Exception e) {
                e.printStackTrace();
            }
        }

        mRecordFragments.clear();

        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mBtnReset.setVisibility(View.INVISIBLE);
            }
        });
    }

    private void startRecording() {
        mAudioRecordThread = new AudioRecordThread();
        mAudioRecordThread.start();
        mVideoRecordThread = new VideoRecordThread();
        mVideoRecordThread.start();
        /////////////////////////////////////////////////////////////////////////////////////////
        //resumeBtnPressed = true;
    }

    private void stopRecording() {
        if (mAudioRecordThread != null) {
            if (mAudioRecordThread.isRunning()) {
                mAudioRecordThread.stopRunning();
            }
        }

        if (mVideoRecordThread != null) {
            if (mVideoRecordThread.isRunning()) {
                mVideoRecordThread.stopRunning();
            }
        }

        try {
            if (mAudioRecordThread != null) {
                mAudioRecordThread.join();
            }
            if (mVideoRecordThread != null) {
                mVideoRecordThread.join();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        mAudioRecordThread = null;
        mVideoRecordThread = null;


        mFrameToRecordQueue.clear();
        mRecycledFrameQueue.clear();


        resumeBtnPressed = false;
    }

    private void resumeRecording() {
        if (!mRecording) {
            RecordFragment recordFragment = new RecordFragment();
            recordFragment.setStartTimestamp(System.currentTimeMillis());
            mRecordFragments.push(recordFragment);
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    mBtnReset.setVisibility(View.VISIBLE);
                    mBtnSwitchCamera.setVisibility(View.INVISIBLE);
                    mBtnResumeOrPause.setText(R.string.pause);
                }
            });
            mRecording = true;
            /////////////////////////////////////////////////////////////////////////////////////////
            resumeBtnPressed = true;
        }
    }

    private void pauseRecording() {
        if (mRecording) {
            mRecordFragments.peek().setEndTimestamp(System.currentTimeMillis());
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    mBtnSwitchCamera.setVisibility(View.VISIBLE);
                    mBtnResumeOrPause.setText(R.string.resume);
                }
            });
            mRecording = false;
            /////////////////////////////////////////////////////////////////////////////////////////
            resumeBtnPressed = false;
        }
    }

    private long calculateTotalRecordedTime(Stack<RecordFragment> recordFragments) {
        long recordedTime = 0;
        for (RecordFragment recordFragment : recordFragments) {
            recordedTime += recordFragment.getDuration();
        }
        return recordedTime;
    }

    class RunningThread extends Thread {
        boolean isRunning;

        public boolean isRunning() {
            return isRunning;
        }

        public void stopRunning() {
            this.isRunning = false;
        }
    }

    class AudioRecordThread extends RunningThread {
        private AudioRecord mAudioRecord;
        private ShortBuffer audioData;

        public AudioRecordThread() {
            int bufferSize = AudioRecord.getMinBufferSize(sampleAudioRateInHz,
                    AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
            mAudioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, sampleAudioRateInHz,
                    AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, bufferSize);

            audioData = ShortBuffer.allocate(bufferSize);
        }

        @Override
        public void run() {
            android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_URGENT_AUDIO);

            Log.d(LOG_TAG, "mAudioRecord startRecording");
            mAudioRecord.startRecording();

            isRunning = true;
            /* ffmpeg_audio encoding loop */
            while (isRunning) {
                if (mRecording && mFrameRecorder != null) {
                    int bufferReadResult = mAudioRecord.read(audioData.array(), 0, audioData.capacity());
                    audioData.limit(bufferReadResult);
                    if (bufferReadResult > 0) {
                        Log.v(LOG_TAG, "bufferReadResult: " + bufferReadResult);
                        try {
                            mFrameRecorder.recordSamples(audioData);
                        } catch (FFmpegFrameRecorder.Exception e) {
                            Log.v(LOG_TAG, e.getMessage());
                            e.printStackTrace();
                        }
                    }
                }
            }
            Log.d(LOG_TAG, "mAudioRecord stopRecording");
            mAudioRecord.stop();
            mAudioRecord.release();
            mAudioRecord = null;
            Log.d(LOG_TAG, "mAudioRecord released");
        }
    }

    class VideoRecordThread extends RunningThread {
        @Override
        public void run() {
            int previewWidth = mPreviewWidth;
            int previewHeight = mPreviewHeight;

            List<String> filters = new ArrayList<>();
            // Transpose
            String transpose = null;
            String hflip = null;
            String vflip = null;
            String crop = null;
            String scale = null;
            int cropWidth;
            int cropHeight;
            Camera.CameraInfo info = new Camera.CameraInfo();
            Camera.getCameraInfo(mCameraId, info);
            int rotation = getWindowManager().getDefaultDisplay().getRotation();
            switch (rotation) {
                case Surface.ROTATION_0:
                    switch (info.orientation) {
                        case 270:
                            if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                                transpose = "transpose=clock_flip"; // Same as preview display
                            } else {
                                transpose = "transpose=cclock"; // Mirrored horizontally as preview display
                            }
                            break;
                        case 90:
                            if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                                transpose = "transpose=cclock_flip"; // Same as preview display
                            } else {
                                transpose = "transpose=clock"; // Mirrored horizontally as preview display
                            }
                            break;
                    }
                    cropWidth = previewHeight;
                    cropHeight = cropWidth * videoHeight / videoWidth;
                    crop = String.format("crop=%d:%d:%d:%d",
                            cropWidth, cropHeight,
                            (previewHeight - cropWidth) / 2, (previewWidth - cropHeight) / 2);
                    // swap width and height
                    scale = String.format("scale=%d:%d", videoHeight, videoWidth);
                    break;
                case Surface.ROTATION_90:
                case Surface.ROTATION_270:
                    switch (rotation) {
                        case Surface.ROTATION_90:
                            // landscape-left
                            switch (info.orientation) {
                                case 270:
                                    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                                        hflip = "hflip";
                                    }
                                    break;
                            }
                            break;
                        case Surface.ROTATION_270:
                            // landscape-right
                            switch (info.orientation) {
                                case 90:
                                    if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
                                        hflip = "hflip";
                                        vflip = "vflip";
                                    }
                                    break;
                                case 270:
                                    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                                        vflip = "vflip";
                                    }
                                    break;
                            }
                            break;
                    }
                    cropHeight = previewHeight;
                    cropWidth = cropHeight * videoWidth / videoHeight;
                    crop = String.format("crop=%d:%d:%d:%d",
                            cropWidth, cropHeight,
                            (previewWidth - cropWidth) / 2, (previewHeight - cropHeight) / 2);
                    scale = String.format("scale=%d:%d", videoWidth, videoHeight);
                    break;
                case Surface.ROTATION_180:
                    break;
            }
            // transpose
            if (transpose != null) {
                filters.add(transpose);
            }
            // horizontal flip
            if (hflip != null) {
                filters.add(hflip);
            }
            // vertical flip
            if (vflip != null) {
                filters.add(vflip);
            }
            // crop
            if (crop != null) {
                filters.add(crop);
            }
            // scale (to designated size)
            if (scale != null) {
                filters.add(scale);
            }

            FFmpegFrameFilter frameFilter = new FFmpegFrameFilter(TextUtils.join(",", filters),
                    previewWidth, previewHeight);
            frameFilter.setPixelFormat(avutil.AV_PIX_FMT_NV21);
            frameFilter.setFrameRate(frameRate);
            try {
                frameFilter.start();
            } catch (FrameFilter.Exception e) {
                e.printStackTrace();
            }

            isRunning = true;
            FrameToRecord recordedFrame;

            while (isRunning || !mFrameToRecordQueue.isEmpty()) {
                try {
                    recordedFrame = mFrameToRecordQueue.take();
                } catch (InterruptedException ie) {
                    ie.printStackTrace();
                    try {
                        frameFilter.stop();
                    } catch (FrameFilter.Exception e) {
                        e.printStackTrace();
                    }
                    break;
                }

                if (mFrameRecorder != null) {
                    long timestamp = recordedFrame.getTimestamp();
                    if (timestamp > mFrameRecorder.getTimestamp()) {
                        mFrameRecorder.setTimestamp(timestamp);
                    }
                    long startTime = System.currentTimeMillis();
//                    Frame filteredFrame = recordedFrame.getFrame();
                    Frame filteredFrame = null;
                    try {
                        frameFilter.push(recordedFrame.getFrame());
                        filteredFrame = frameFilter.pull();
                    } catch (FrameFilter.Exception e) {
                        e.printStackTrace();
                    }
                    try {
                        mFrameRecorder.record(filteredFrame);
                    } catch (FFmpegFrameRecorder.Exception e) {
                        e.printStackTrace();
                    }
                    long endTime = System.currentTimeMillis();
                    long processTime = endTime - startTime;
                    mTotalProcessFrameTime += processTime;
                    Log.d(LOG_TAG, "This frame process time: " + processTime + "ms");
                    long totalAvg = mTotalProcessFrameTime / ++mFrameRecordedCount;
                    Log.d(LOG_TAG, "Avg frame process time: " + totalAvg + "ms");
                }
                Log.d(LOG_TAG, mFrameRecordedCount + " / " + mFrameToRecordCount);
                mRecycledFrameQueue.offer(recordedFrame);
            }
        }

        public void stopRunning() {
            super.stopRunning();
            if (getState() == WAITING) {
                interrupt();
            }
        }
    }

    abstract class ProgressDialogTask<Params, Progress, Result> extends AsyncTask<Params, Progress, Result> {

        private int promptRes;
        private ProgressDialog mProgressDialog;

        public ProgressDialogTask(int promptRes) {
            this.promptRes = promptRes;
        }

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            mProgressDialog = ProgressDialog.show(FFmpegRecordActivity.this,
                    null, getString(promptRes), true);
        }

        @Override
        protected void onProgressUpdate(Progress... values) {
            super.onProgressUpdate(values);
//            mProgressDialog.setProgress(values[0]);
        }

        @Override
        protected void onPostExecute(Result result) {
            super.onPostExecute(result);
            mProgressDialog.dismiss();
        }
    }

    class FinishRecordingTask extends ProgressDialogTask<Void, Integer, Void> {

        public FinishRecordingTask() {
            super(R.string.processing);
        }

        @Override
        protected Void doInBackground(Void... params) {
            stopRecording();
            stopRecorder();
            releaseRecorder(false);
            return null;
        }

        // Declaring values for statistics calculation
//        private float hrAvg;
//        private float oxAvg;
//        private float tempAvg;
//        private float audioAvg;
//        private float stretchAvg;
//        private float yawAvg;
//        private float pitchAvg;
//        private float rollAvg;


//        hrTtl = hrTtl + hr_only_float;
//        oxTtl = oxTtl + ox_only_float;
//        tempTtl = tempTtl + temp_only_float;
//        audioTtl = audioTtl + audio_only_float;
//        stretchTtl = stretchTtl + stretch_only_float;
//        yawTtl = yawTtl + yaw_only_float;
//        pitchTtl = pitchTtl + pitch_only_float;
//        rollTtl = rollTtl + roll_only_float;



//        hrAvg =
//        oxAvg
//        tempAvg




        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            Intent intent = new Intent(FFmpegRecordActivity.this, PlaybackActivity.class);
            intent.putExtra(PlaybackActivity.INTENT_NAME_VIDEO_PATH, mVideo.getPath());
            //intent.putExtra(PlaybackActivity.INTENT_NAME_TEXT_PATH, mText.getPath());
            intent.putExtra(PlaybackActivity.INTENT_NAME_TEXT_PATH, mText.getPath());
            startActivity(intent);

        }
    }


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.menu_main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle item selection
        switch (item.getItemId()) {
            case R.id.close:
                b.removeCommunicationCallback();
                b.disconnect();
                Intent intent = new Intent(this, Select.class);
                startActivity(intent);
                finish();
                return true;

            case R.id.rate:
                Uri uri = Uri.parse("market://details?id=" + this.getPackageName());
                Intent goToMarket = new Intent(Intent.ACTION_VIEW, uri);
                goToMarket.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY | Intent.FLAG_ACTIVITY_NEW_DOCUMENT | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
                try {
                    startActivity(goToMarket);
                } catch (ActivityNotFoundException e) {
                    startActivity(new Intent(Intent.ACTION_VIEW,
                            Uri.parse("http://play.google.com/store/apps/details?id=" + this.getPackageName())));
                }
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
    }

    public void Display(final String s){
        this.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                text.append(s + "\n");
                scrollView.fullScroll(View.FOCUS_DOWN);
            }
        });
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////

    @Override
    public void onConnect(BluetoothDevice device) {
        Display("Connected to "+device.getName()+" - "+device.getAddress());
        this.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                ////////////////////////////////////////////////////////////////////////////////////////////////
                send.setEnabled(true);
                ////////////////////////////////////////////////////////////////////////////////////////////////
            }
        });
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////
    @Override
    public void onDisconnect(BluetoothDevice device, String message) {
        Display("Disconnected!");
        Display("Connecting again...");
        b.connectToDevice(device);
    }

    //File root = new File(DIRECTORY_PATH);
    //File gpxfile = new File(root, "samples.txt");

    @RequiresApi(api = Build.VERSION_CODES.O)
    @Override
    public void onMessage(String message) {

        //FileOutputStream outputStream;
         /*else {
            try {
                mText = CameraHelper.getOutputMediaFile(recordedTime, CameraHelper.MEDIA_TYPE_TEXT);
                FileWriter writer = new FileWriter(mText);
                writer.append("First string is here to be written.");
                writer.flush();
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }*/
        ///////////////////////////////////////////////////////////////////////////////////////
/*        if (sensorValueIndex == 0) {
            sensorHeaderCheck = true;
            try {
                /////////////////////////////////////////////////////
                //writer.append(message);
                /////////////////////////////////////////////////////
                writer.append("ID");
                writer.append(",");
                writer.append("Time");
                writer.append(",");
                writer.append("HR");
                writer.append(",");
                writer.append("Ox Rate");
                writer.append(",");
                writer.append("Temp");
                writer.append("\n");
                writer.flush();
                //writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }*/
        ///////////////////////////////////////////////////////////////////////////////////////

        //if (resumeBtnPressed == true) {
            ///////////////////////////////////////////////////////////////////////////////////////
            int first = message.indexOf("/");
            int second = message.indexOf("/",first+1);
            int third = message.indexOf("/",second+1);
            int fourth = message.indexOf("/",third+1);
            int fivth = message.indexOf("/",fourth+1);
            int sixth = message.indexOf("/",fivth+1);
            int seventh = message.indexOf("/",sixth+1);
            int eighth = message.indexOf("/",seventh+1);
            int ninth = message.indexOf("/",eighth+1);
            int tenth = message.indexOf("/",ninth+1);
            int eleventh = message.indexOf("/",tenth+1);
            int twelfth = message.indexOf("/",eleventh+1);
            int thirteenth = message.indexOf("/",twelfth+1);
            int fourteenth = message.indexOf("/",thirteenth+1);
            int fifteenth = message.indexOf("/",fourteenth+1);
            int sixteenth = message.indexOf("/",fifteenth+1);
            int seventeenth = message.indexOf("/",sixteenth+1);

            String index_header = "Order";
            String time_header = "Time";
            String hr_header = "HR";
            String ox_header = "Ox";
            String temp_header = "Temp";
            String stretch_header = "Stretch";
            String audio_header = "Audio";
            String yaw_header = "Yaw";
            String pitch_header = "Pitch";
            String roll_jeader = "Roll";

            final String index_only = String.valueOf(sensorValueIndex);
            final String time_only = message.substring(first+1,second);
            final String hr_only = message.substring(third+1,fourth);
            final String ox_only = message.substring(fivth+1,sixth);
            final String temp_only = message.substring(seventh+1,eighth);
            final String yaw_only = message.substring(ninth+1,tenth);
            final String pitch_only = message.substring(eleventh+1,twelfth);
            final String roll_only = message.substring(thirteenth+1,fourteenth);
            final String audio_only = message.substring(fifteenth+1,sixteenth);
            final String stretch_only = message.substring(seventeenth+1,message.length()-1);

            final float hr_only_float  = Float.parseFloat(hr_only);
            float ox_only_float  = Float.parseFloat(ox_only);
            float temp_only_float  = Float.parseFloat(temp_only);
            float yaw_only_float  = Float.parseFloat(yaw_only);
            float pitch_only_float  = Float.parseFloat(pitch_only);
            float roll_only_float  = Float.parseFloat(roll_only);
            float audio_only_float = Float.parseFloat(audio_only);
            float stretch_only_float = Float.parseFloat(stretch_only);

            hrTtl = hrTtl + hr_only_float;
            oxTtl = oxTtl + ox_only_float;
            tempTtl = tempTtl + temp_only_float;
            audioTtl = audioTtl + audio_only_float;
            stretchTtl = stretchTtl + stretch_only_float;
            yawTtl = yawTtl + yaw_only_float;
            pitchTtl = pitchTtl + pitch_only_float;
            rollTtl = rollTtl + roll_only_float;

            sensValCount = sensValCount + 1;

            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    timeinfo.setText(time_only);
                    hrinfo.setText(hr_only);
                    oxinfo.setText(ox_only);
                    tenoinfo.setText(temp_only);
                    // Later added
                    yawInfo.setText(yaw_only);
                    pitchInfo.setText(pitch_only);
                    rollInfo.setText(roll_only);
                    audioInfo.setText(audio_only);
                    stretchInfo.setText(stretch_only);
//stuff that updates ui
////
                }
            });

        new Thread(new Runnable() {
            @Override
            public void run() {
                // add 100 entries
                for (int i = 0; i < 200; i++) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {


                            LineData data = mChart1.getData();
                            //--//
                            if (data != null) {
                                LineDataSet set = (LineDataSet) data.getDataSetByIndex(0);

                                if (set == null) {
                                    set = createSet();
                                    data.addDataSet(set);
                                }

                                // add a new random value
                                data.addXValue("");
                                data.addEntry(new Entry(hr_only_float, set.getEntryCount()),0);

                                //enable chart data has changed
                                mChart1.notifyDataSetChanged();

                                // limit number of visible entries
                                //mChart.setVisibleXRange(5,7);
                                mChart1.setVisibleXRange(6);

                                // scroll to the last entry
                                //mChart.moveViewToX(data.getEntryCount() - 7);

                                mChart1.moveViewToX(data.getXValCount() - 7);
                            }
                            //--/

                        }
                    });

                    // pause between adds
                    try {
                        Thread.sleep(600);
                    } catch (InterruptedException e) {
                        // manage errors
                        //e.printStackTrace();
                    }
                }
            }
        }).start();

            Display(name+": "+message);

            //File file = new File("foo.csv");

            /*
            CsvWriter csvWriter = new CsvWriter();
            //if (mText.exists()) {
            //////////////////////////////////////////////////////////////////////////////////////////
            //try (CsvAppender csvAppender = csvWriter.append(mText, StandardCharsets.UTF_8)) {
            try (CsvAppender csvAppender = csvWriter.append(file, StandardCharsets.UTF_8)) {
                csvAppender.appendLine("header1", "header2");
                // 1st line in one operation
                csvAppender.appendLine("value1", "value2");
                csvAppender.endLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            */
            if (sensorValueIndex == 0) {
                try {
                    /////////////////////////////////////////////////////
                    //writer.append(message);
                    /////////////////////////////////////////////////////
                    writer.append(index_header);
                    writer.append(",");
                    writer.append(time_header);
                    writer.append(",");
                    writer.append(hr_header);
                    writer.append(",");
                    writer.append(ox_header);
                    writer.append(",");
                    writer.append(temp_header);
                    writer.append(",");
                    writer.append(stretch_header);
                    writer.append(",");
                    writer.append(audio_header);
                    writer.append(",");
                    writer.append(yaw_header);
                    writer.append(",");
                    writer.append(pitch_header);
                    writer.append(",");
                    writer.append(roll_jeader);
                    writer.append("\n");
                    writer.flush();
                    sensorValueIndex = sensorValueIndex + 1;
                    //writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } else {
                try {

                    /////////////////////////////////////////////////////
                    //writer.append(message);
                    /////////////////////////////////////////////////////
                    writer.append(index_only);
                    writer.append(",");
                    writer.append(time_only);
                    writer.append(",");
                    writer.append(hr_only);
                    writer.append(",");
                    writer.append(ox_only);
                    writer.append(",");
                    writer.append(temp_only);
                    writer.append(",");
                    writer.append(stretch_only);
                    writer.append(",");
                    writer.append(audio_only);
                    writer.append(",");
                    writer.append(yaw_only);
                    writer.append(",");
                    writer.append(pitch_only);
                    writer.append(",");
                    writer.append(roll_only);
                    writer.append("\n");
                    writer.flush();
                    sensorValueIndex = sensorValueIndex + 1;
                    //writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }



            //if (sensorHeaderCheck == true) {

            //}

            //////////////////////////////////////////////////////////////////////////////////////////
            //}
/*            try {
                outputStream = openFileOutput("logslogslogs", Context.MODE_PRIVATE);
                outputStream.write(message.getBytes());
                outputStream.close();
                Toast.makeText(this, message, Toast.LENGTH_LONG).show();

            } catch (Throwable t){
                //Toast.makeText(this, "Exception: " + t.toString(), Toast.LENGTH_LONG).show();
            }*/
        //}
        //Display(name+": "+message);
    }

    @Override
    public void onError(String message)  {
        Display("Error: "+message);
    }

    @Override
    public void onConnectError(final BluetoothDevice device, String message) {
        Display("Error: "+message);
        Display("Trying again in 3 sec.");
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Handler handler = new Handler();
                handler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        b.connectToDevice(device);
                    }
                }, 2000);
            }
        });
    }

    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            final String action = intent.getAction();

            if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
                final int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR);
                //Intent intent1 = new Intent(Chat.this, Select.class);
                Intent intent1 = new Intent(FFmpegRecordActivity.this, Select.class);

                switch (state) {
                    case BluetoothAdapter.STATE_OFF:
                        if(registered) {
                            unregisterReceiver(mReceiver);
                            registered=false;
                        }
                        startActivity(intent1);
                        finish();
                        break;
                    case BluetoothAdapter.STATE_TURNING_OFF:
                        if(registered) {
                            unregisterReceiver(mReceiver);
                            registered=false;
                        }
                        startActivity(intent1);
                        finish();
                        break;
                }
            }
        }
    };

    private LineDataSet createSet() {
        LineDataSet set = new LineDataSet(null, "Data");
        //set.setDrawCubic(boolean enabled)
        //set.setMode(LineDataSet.Mode.CUBIC_BEZIER);
        set.setDrawCubic(true);
        set.setCubicIntensity(0.2f);
        set.setAxisDependency(YAxis.AxisDependency.LEFT);
        set.setColor(ColorTemplate.getHoloBlue());
        set.setCircleColor(ColorTemplate.getHoloBlue());
        set.setLineWidth(2f);
        set.setCircleSize(4f);
        set.setFillAlpha(65);
        set.setFillColor(ColorTemplate.getHoloBlue());
        set.setHighLightColor(Color.rgb(244,117,177));
        set.setValueTextColor(Color.WHITE);
        set.setValueTextSize(10f);

        return set;
    }


}