Coding Cats Tune-In: Building an Audio Recording App with Kotlin and Java

 

Welcome back, Coding Cats enthusiasts! Today, we're going to let the musical notes fly as we build an audio recording app using a fusion of Java and Kotlin. Let's explore the harmony between these two languages and discover how they can be orchestrated together to create a stunning symphony.

Prelude: Introducing Kotlin and Java

Our duo for today's performance, Kotlin and Java, have unique strengths that make them music to a developer's ears. Java, the maestro, is the most used language for Android development, renowned for its robustness and simplicity. On the other hand, Kotlin, the prodigy, is officially supported by Google for Android development due to its null safety, conciseness, and easy interoperability with Java.

Setting the Stage

We'll build an Android application with a simple UI that allows users to record audio and play the recorded audio files. Let's create our new Android Studio project and select Kotlin as our language for the MainActivity.

Interlude: Integrating Java

Kotlin's interoperability with Java means we can call Java code from Kotlin and vice versa. For our audio recording app, we will use Java to handle the audio recording and playback functionality. Here's how you can create a new Java class in your Kotlin project:

1. Right-click on your (module) app.
2. Navigate to New > Java Class.
3. Name it "AudioHandler".

Let's start the composition by writing the AudioHandler in Java.

java

import android.media.MediaPlayer;
import android.media.MediaRecorder;
import java.io.IOException;

public class AudioHandler {
    private MediaRecorder recorder = null;
    private MediaPlayer player = null;

    // Start Recording
    public void startRecording(String path) throws IOException {
        recorder = new MediaRecorder();
        recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
        recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
        recorder.setOutputFile(path);
        recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
        recorder.prepare();
        recorder.start();
    }

    // Stop Recording
    public void stopRecording() {
        if (recorder != null) {
            recorder.release();
            recorder = null;
        }
    }

    // Start Playback
    public void startPlaying(String path) throws IOException {
        player = new MediaPlayer();
        player.setDataSource(path);
        player.prepare();
        player.start();
    }

    // Stop Playback
    public void stopPlaying() {
        if (player != null) {
            player.release();
            player = null;
        }
    }
}

Encore: Kotlin Comes into Play

With our Java class handling the audio recording and playback, let's utilize Kotlin for our MainActivity. We'll make calls to our AudioHandler from our Kotlin activity:

kotlin

import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import java.io.IOException

class MainActivity : AppCompatActivity() {
    private var audioHandler: AudioHandler? = null
    private val audioPath: String
        get() = "${externalCacheDir?.absolutePath}/audiorecord.3gp"

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

    fun startRecording(view: View) {
        try {
            audioHandler?.startRecording(audioPath)
        } catch (e: IOException) {
            e.printStackTrace()
        }
    }

    fun stopRecording(view: View) {
        audioHandler?.stopRecording()
    }

    fun startPlaying(view: View) {
        try {
            audioHandler?.startPlaying(audioPath)
        } catch (e: IOException) {
            e.printStackTrace()
        }
    }

    fun stopPlaying(view: View) {
        audioHandler?.stopPlaying()
    }
}

In the code above, we use Kotlin's null safety features with the ? operator and safe calls to the methods of our Java class, ensuring a symphonic performance devoid of abrupt crashes.

Finale: Mastering the Duet

Building an audio recording app is a great way to explore and understand the harmonious relationship between Kotlin and Java. It exemplifies the power and versatility of the JVM ecosystem and proves that these two languages can be used in perfect harmony to build robust Android applications.

Our coding cats have truly mastered the duet of Kotlin and Java. How about you? Stay tuned for more adventures in the world of coding. Until then, keep striking those chords and happy coding!