Doubt about the operation of the AudioRecord class

I am a beginner and I was trying to understand how to record an audio using android and how it processes that audio. And during the searches I found this site: Audio Record
The example works perfectly. But I did not really understand how this class works to capture the sound and be able to record that sound. It is known that in digital processing the samples are sampled (number of samples per second) and then these values are converted into binary codes according to the voltage ranges. So the higher the number of bits, the more accurate the sound identification will be. In the example below it uses 16 bits. So I'm in doubt about how to relate what it does to digital audio processing in fact.

In the documentation it says:

  

Returns the minimum buffer size required for the successful creation of an AudioRecord object, in byte units. Note that this size does not guarantee smooth recording under load, and higher values should be chosen according to the expected frequency at which the AudioRecord instance will be polled for new data. See AudioRecord (int, int, int, int, int) for more information on valid configuration values.   I did not understand this question of him having to give me the minimal bugffer. What prevents me from setting the buffer?

  

int: the total size (in bytes) of the buffer where audio data is written to during the recording. New audio data can be read from this buffer in smaller chunks than this size. I am trying to create an audioRecord instance in an audioRecord instance. Using values smaller than getMinBufferSize () will result in an initialization failure.   What does this parameter represent, since it first uses buffersize = getminbuffersize () and then it uses "BufferElements2Rec" and "BytesPerElement"?

In my understanding, he would take samples of the sound and record the voltage levels converted to a binary number. I do not get it right or does he do it? If anyone can help in understanding this, I would be grateful!

            import java.io.FileNotFoundException;
            import java.io.FileOutputStream;
            import java.io.IOException;
            import android.app.Activity;
            import android.media.AudioFormat;
            import android.media.AudioRecord;
            import android.media.MediaRecorder;
            import android.os.Bundle;
            import android.view.KeyEvent;
            import android.view.View;
            import android.widget.Button;

            /**
            *
            * @author RAHUL BARADIA
            *
            *
            */
            public class Audio_Record extends Activity {
            private static final int RECORDER_SAMPLERATE = 8000;

            private static final int RECORDER_CHANNELS = AudioFormat.CHANNEL_IN_MONO;

            private static final int RECORDER_AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;

            private AudioRecord recorder = null;
            private Thread recordingThread = null;
            private boolean isRecording = false;

            @Override
            public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);

            setButtonHandlers();
            enableButtons(false);

            int bufferSize = AudioRecord.getMinBufferSize(RECORDER_SAMPLERATE,
            RECORDER_CHANNELS, RECORDER_AUDIO_ENCODING);
            }

            private void setButtonHandlers() {
            ((Button) findViewById(R.id.btnStart)).setOnClickListener(btnClick);
            ((Button) findViewById(R.id.btnStop)).setOnClickListener(btnClick);
            }

            private void enableButton(int id, boolean isEnable) {
            ((Button) findViewById(id)).setEnabled(isEnable);
            }

            private void enableButtons(boolean isRecording) {
            enableButton(R.id.btnStart, !isRecording);
            enableButton(R.id.btnStop, isRecording);
            }

            int BufferElements2Rec = 1024; // want to play 2048 (2K) since 2 bytes we use only 1024
            int BytesPerElement = 2; // 2 bytes in 16bit format

            private void startRecording() {

            recorder = new AudioRecord(MediaRecorder.AudioSource.MIC,
            RECORDER_SAMPLERATE, RECORDER_CHANNELS,
            RECORDER_AUDIO_ENCODING, BufferElements2Rec * BytesPerElement);

            recorder.startRecording();

            isRecording = true;

            recordingThread = new Thread(new Runnable() {

            public void run() {

            writeAudioDataToFile();

            }
            }, "AudioRecorder Thread");
            recordingThread.start();
            }

            //Conversion of short to byte
            private byte[] short2byte(short[] sData) {
            int shortArrsize = sData.length;
            byte[] bytes = new byte[shortArrsize * 2];

            for (int i = 0; i < shortArrsize; i++) {
            bytes[i * 2] = (byte) (sData[i] & 0x00FF);
            bytes[(i * 2) + 1] = (byte) (sData[i] >> 8);
            sData[i] = 0;
            }
            return bytes;
            }

            private void writeAudioDataToFile() {
            // Write the output audio in byte
            String filePath = "/sdcard/8k16bitMono.pcm";

                    short sData[] = new short[BufferElements2Rec];

            FileOutputStream os = null;
            try {
            os = new FileOutputStream(filePath);
            } catch (FileNotFoundException e) {
            e.printStackTrace();
            }

            while (isRecording) {
            // gets the voice output from microphone to byte format
            recorder.read(sData, 0, BufferElements2Rec);
            System.out.println("Short wirting to file" + sData.toString());
            try {
            // writes the data to file from buffer stores the voice buffer
            byte bData[] = short2byte(sData);

            os.write(bData, 0, BufferElements2Rec * BytesPerElement);

            } catch (IOException e) {
            e.printStackTrace();
            }
            }

            try {
            os.close();
            } catch (IOException e) {
            e.printStackTrace();
            }
            }

            private void stopRecording() {
            // stops the recording activity
            if (null != recorder) {
            isRecording = false;


            recorder.stop();
            recorder.release();

            recorder = null;
            recordingThread = null;
            }
            }

            private View.OnClickListener btnClick = new View.OnClickListener() {
            public void onClick(View v) {
            switch (v.getId()) {
            case R.id.btnStart: {
            enableButtons(true);
            startRecording();
            break;
            }
            case R.id.btnStop: {
            enableButtons(false);
            stopRecording();
            break;
            }
            }
            }
            };

            // onClick of backbutton finishes the activity.
            @Override
            public boolean onKeyDown(int keyCode, KeyEvent event) {
            if (keyCode == KeyEvent.KEYCODE_BACK) {
            finish();
            }
            return super.onKeyDown(keyCode, event);
            }
            }