Android Recording App

Recording App

Recording App:

A recording app in this context to the Android platform means a software application that is installed on a smartphone and used to capture audio, video or both and store.

These apps extend capabilities to record a broad range of content to your Android smartphones or tablets.

Example:

                                    
// add following permission in AndroidManifest.xml
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.STORAGE" />


// main_activity.java
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".recordingapp.RecordingAppFragment"
    android:padding="16dp">

    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:scrollbars="none">

        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:gravity="center"
            android:layout_gravity="center">

            <Button
                android:id="@+id/startrecord"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="Start Recording"
                android:textSize="16sp"
                android:textColor="#FFFFFF"
                android:padding="16dp"
                android:background="@color/colorPrimaryDark" />

            <Button
                android:layout_below="@id/startrecord"
                android:id="@+id/stopRecording"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="Stop Recording"
                android:textSize="16sp"
                android:textColor="#FFFFFF"
                android:padding="16dp"
                android:background="@color/colorPrimaryDark"
                android:layout_marginTop="10dp" />

            <Button
                android:layout_below="@id/stopRecording"
                android:id="@+id/playRecording"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="Play Recording"
                android:textSize="16sp"
                android:textColor="#FFFFFF"
                android:padding="16dp"
                android:background="@color/colorPrimaryDark"
                android:layout_marginTop="10dp" />

            <Button
                android:layout_below="@id/playRecording"
                android:id="@+id/stop_playing_record"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="Stop Playing Record"
                android:textSize="16sp"
                android:textColor="#FFFFFF"
                android:padding="16dp"
                android:background="@color/colorPrimaryDark"
                android:layout_marginTop="10dp" />

        </RelativeLayout>
    </ScrollView>

</RelativeLayout>

                                    
                                        import android.content.pm.PackageManager;
import android.media.MediaPlayer;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.os.Environment;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import java.io.IOException;
import java.util.Random;

import static android.Manifest.permission.RECORD_AUDIO;
import static android.Manifest.permission.WRITE_EXTERNAL_STORAGE;

public class MainActivity extends AppCompatActivity {

    Button bStart, bStop, bPlayLastRecordAudio, bStopPlayingRecording;
    String AudioSavePathInDevice = null;
    MediaRecorder mediaRecorder;
    Random random;
    String RandomAudioFileName = "RecordAudio";
    public static final int RequestPermissionCode = 1;
    MediaPlayer mediaPlayer;

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

        bStart = (Button) findViewById(R.id.startrecord);
        bStop = (Button) findViewById(R.id.stopRecording);
        bPlayLastRecordAudio = (Button) findViewById(R.id.playRecording);
        bStopPlayingRecording = (Button) findViewById(R.id.stop_playing_record);

        bStop.setEnabled(false);
        bPlayLastRecordAudio.setEnabled(false);
        bStopPlayingRecording.setEnabled(false);

        random = new Random();

        bStart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (checkPermission()) {
                    AudioSavePathInDevice = Environment.getExternalStorageDirectory().getAbsolutePath() + "/" +
                            CreateRandomAudioFileName(5) + "AudioRecording.3gp";

                    MediaRecorderReady();

                    try {
                        mediaRecorder.prepare();
                        mediaRecorder.start();
                    } catch (IllegalStateException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                    bStart.setEnabled(false);
                    bStop.setEnabled(true);

                    Toast.makeText(MainActivity.this, "Recording started now", Toast.LENGTH_LONG).show();
                } else {
                    requestPermission();
                }
            }
        });

        bStop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                mediaRecorder.stop();
                bStop.setEnabled(false);
                bPlayLastRecordAudio.setEnabled(true);
                bStart.setEnabled(true);
                bStopPlayingRecording.setEnabled(false);

                Toast.makeText(MainActivity.this, "Recording Completed now", Toast.LENGTH_LONG).show();
            }
        });

        bPlayLastRecordAudio.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) throws IllegalArgumentException,
                    SecurityException, IllegalStateException {
                bStop.setEnabled(false);
                bStart.setEnabled(false);
                bStopPlayingRecording.setEnabled(true);

                mediaPlayer = new MediaPlayer();
                try {
                    mediaPlayer.setDataSource(AudioSavePathInDevice);
                    mediaPlayer.prepare();
                } catch (IOException e) {
                    e.printStackTrace();
                }

                mediaPlayer.start();
                Toast.makeText(MainActivity.this, "Recording Playing now", Toast.LENGTH_LONG).show();
            }
        });

        bStopPlayingRecording.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                bStop.setEnabled(false);
                bStart.setEnabled(true);
                bStopPlayingRecording.setEnabled(false);
                bPlayLastRecordAudio.setEnabled(true);

                if (mediaPlayer != null) {
                    mediaPlayer.stop();
                    mediaPlayer.release();
                    MediaRecorderReady();
                    Toast.makeText(MainActivity.this, "Playing audio stopped", Toast.LENGTH_LONG).show();
                }
            }
        });
    }

    public void MediaRecorderReady() {
        mediaRecorder = new MediaRecorder();
        mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
        mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
        mediaRecorder.setAudioEncoder(MediaRecorder.OutputFormat.AMR_NB);
        mediaRecorder.setOutputFile(AudioSavePathInDevice);
    }

    public String CreateRandomAudioFileName(int string) {
        StringBuilder stringBuilder = new StringBuilder(string);
        int i = 0;
        while (i < string) {
            stringBuilder.append(RandomAudioFileName.charAt(random.nextInt(RandomAudioFileName.length())));
            i++;
        }
        return stringBuilder.toString();
    }

    private void requestPermission() {
        ActivityCompat.requestPermissions(MainActivity.this, new
                String[]{WRITE_EXTERNAL_STORAGE, RECORD_AUDIO}, RequestPermissionCode);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           String permissions[], int[] grantResults) {
        switch (requestCode) {
            case RequestPermissionCode:
                if (grantResults.length > 0) {
                    boolean StoragePermission = grantResults[0] == PackageManager.PERMISSION_GRANTED;
                    boolean RecordPermission = grantResults[1] == PackageManager.PERMISSION_GRANTED;

                    if (StoragePermission && RecordPermission) {
                        Toast.makeText(MainActivity.this, "Permission Granted", Toast.LENGTH_LONG).show();
                    } else {
                        Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_LONG).show();
                    }
                }
                break;
        }
    }

    public boolean checkPermission() {
        int result = ContextCompat.checkSelfPermission(getApplicationContext(),
                WRITE_EXTERNAL_STORAGE);
        int result1 = ContextCompat.checkSelfPermission(getApplicationContext(),
                RECORD_AUDIO);
        return result == PackageManager.PERMISSION_GRANTED &&
                result1 == PackageManager.PERMISSION_GRANTED;
    }
}

                                      
                                        import android.content.pm.PackageManager
import android.media.MediaPlayer
import android.media.MediaRecorder
import android.os.Bundle
import android.os.Environment
import android.view.View
import android.widget.Button
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import java.io.IOException
import java.util.Random

class MainActivity : AppCompatActivity() {

    private lateinit var bStart: Button
    private lateinit var bStop: Button
    private lateinit var bPlayLastRecordAudio: Button
    private lateinit var bStopPlayingRecording: Button
    private var audioSavePathInDevice: String? = null
    private lateinit var mediaRecorder: MediaRecorder
    private lateinit var random: Random
    private val randomAudioFileName = "RecordAudio"
    private val requestPermissionCode = 1
    private lateinit var mediaPlayer: MediaPlayer

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        bStart = findViewById(R.id.startrecord)
        bStop = findViewById(R.id.stopRecording)
        bPlayLastRecordAudio = findViewById(R.id.playRecording)
        bStopPlayingRecording = findViewById(R.id.stop_playing_record)

        bStop.isEnabled = false
        bPlayLastRecordAudio.isEnabled = false
        bStopPlayingRecording.isEnabled = false

        random = Random()

        bStart.setOnClickListener {
            if (checkPermission()) {
                audioSavePathInDevice =
                    Environment.getExternalStorageDirectory().absolutePath + "/" +
                            createRandomAudioFileName(5) + "AudioRecording.3gp"

                mediaRecorderReady()

                try {
                    mediaRecorder.prepare()
                    mediaRecorder.start()
                } catch (e: IllegalStateException) {
                    e.printStackTrace()
                } catch (e: IOException) {
                    e.printStackTrace()
                }

                bStart.isEnabled = false
                bStop.isEnabled = true

                Toast.makeText(this@MainActivity, "Recording started now", Toast.LENGTH_LONG).show()
            } else {
                requestPermission()
            }
        }

        bStop.setOnClickListener {
            mediaRecorder.stop()
            bStop.isEnabled = false
            bPlayLastRecordAudio.isEnabled = true
            bStart.isEnabled = true
            bStopPlayingRecording.isEnabled = false

            Toast.makeText(this@MainActivity, "Recording Completed now", Toast.LENGTH_LONG).show()
        }

        bPlayLastRecordAudio.setOnClickListener {
            bStop.isEnabled = false
            bStart.isEnabled = false
            bStopPlayingRecording.isEnabled = true

            mediaPlayer = MediaPlayer()
            try {
                mediaPlayer.setDataSource(audioSavePathInDevice)
                mediaPlayer.prepare()
            } catch (e: IOException) {
                e.printStackTrace()
            }

            mediaPlayer.start()
            Toast.makeText(this@MainActivity, "Recording Playing now", Toast.LENGTH_LONG).show()
        }

        bStopPlayingRecording.setOnClickListener {
            bStop.isEnabled = false
            bStart.isEnabled = true
            bStopPlayingRecording.isEnabled = false
            bPlayLastRecordAudio.isEnabled = true

            mediaPlayer.takeIf { it != null }?.apply {
                stop()
                release()
                mediaRecorderReady()
                Toast.makeText(this@MainActivity, "Playing audio stopped", Toast.LENGTH_LONG).show()
            }
        }
    }

    private fun mediaRecorderReady() {
        mediaRecorder = MediaRecorder()
        mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC)
        mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP)
        mediaRecorder.setAudioEncoder(MediaRecorder.OutputFormat.AMR_NB)
        mediaRecorder.setOutputFile(audioSavePathInDevice)
    }

    private fun createRandomAudioFileName(string: Int): String {
        val stringBuilder = StringBuilder(string)
        var i = 0
        while (i < string) {
            stringBuilder.append(randomAudioFileName[random.nextInt(randomAudioFileName.length)])
            i++
        }
        return stringBuilder.toString()
    }

    private fun requestPermission() {
        ActivityCompat.requestPermissions(
            this@MainActivity,
            arrayOf(WRITE_EXTERNAL_STORAGE, RECORD_AUDIO),
            requestPermissionCode
        )
    }

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array,
        grantResults: IntArray
    ) {
        when (requestCode) {
            requestPermissionCode -> {
                if (grantResults.isNotEmpty()) {
                    val storagePermission = grantResults[0] == PackageManager.PERMISSION_GRANTED
                    val recordPermission = grantResults[1] == PackageManager.PERMISSION_GRANTED

                    if (storagePermission && recordPermission) {
                        Toast.makeText(this@MainActivity, "Permission Granted", Toast.LENGTH_LONG).show()
                    } else {
                        Toast.makeText(this@MainActivity, "Permission Denied", Toast.LENGTH_LONG).show()
                    }
                }
            }
        }
    }

    private fun checkPermission(): Boolean {
        val resultStorage = ContextCompat.checkSelfPermission(
            applicationContext,
            WRITE_EXTERNAL_STORAGE
        )
        val resultRecord = ContextCompat.checkSelfPermission(
            applicationContext,
            RECORD_AUDIO
        )
        return resultStorage == PackageManager.PERMISSION_GRANTED && resultRecord == PackageManager.PERMISSION_GRANTED
    }
}