Media player android kotlin

Media player android kotlin

Starting with Android Marshmallow (6.0), certain types of permissions require explicit permission from the user, from within the app, in addition to being specified in the AndroidManifest.xml file. This includes accessing the microphone and writing to external storage — both of which this app will need to do

1. Open the AndroidManifest.xml file and add the following permissions inside the element:
2. Next return to the MainActivity class and add a property to store a request code for the permissions request as follows: The actual value of the request is arbitrary
3. Add the following method to check for each permission, and where permission is not granted, request permission:
4. Call this method from the within onCreate method

Playback and recording audio

The application needs to be able to start and stop recording, as well as start and stop playback. Adding all this functionality within the Activity would make it less reuable, so we will create a class with the responsibility for recording and playback

1. Add a new Kotlin class called AudioManager
2. Set the primary constructor for the audio manager so that it has declares a val named context of type Context
3. Add two properties for a MediaRecorder and MediaPlayer as follows:
4. When files are saved, we will used an id (corresponding to their position on the soundboard). Add the following method to the AudioManager class to retrieve a file path for a given id as follows:Ideally we would use an unsigned integer for the Id, to ensure a valid file path name, but at the time of writing Kotlin’s unsigned integers are still experimental
5. Next add a method setup a MediaRecorder object and start recording. Pay attention to the comments in the code which explain what is happening The MediaRecorder class can use a range for formats and file types, detailed here
6. Stopping the recording is a little easier, add the following method which will do that:
7. To playback the audio, we use the MediaPlayer object, but less configuration is required, add the following methods to start and stop playback:
8. Return to the MainActivity and declare an instance of the AudioManager class as follows:
9. Next in the onCreate method, instantiate the audioManager object as follows:

Handling touch events to start and stop recording and playback

The app is designed to work in such a way that holding down on a button will either play or record audio associated with that button. Whether audio is played or recorded will depend on the state of the ToggleButton.

1. Add an implementation of the View.OnTouchListener interface as follows:
2. Locate the //todo: comment in the drawBoard method, and replace it with the following:
3. Run the application and make sure it works as expected. Be aware that if you use an emulator the recorded audio may be severely distorted (at the time of writing the documentation states that it does not work). If you are able, test on an Android phone or tablet

Tasks

• If permissions are not granted (or revoked in settings) by the user, the application will crash, adapt the code so this cannot happen
• If you’ve not already done so in the above task, research how to use provide a rationale for the permissions in the event a user declines the permission request
• For each button make it clear whether or not a recording exists already for the button
• Modify the code so that if recording mode is enabled and a user tried to record over an existing recording, instead of starting recording, they are prompted to chose whether or not to remove the existing one
• The class to MediaPlayer’s prepare method should not be called on the main thread. Use the prepareAsync method instead and use an implementation of the OnPreparedListener interface to start playback

This site uses cookies for analytics, you may disable them in your browser settings

Источник

How to play audio using the MediaPlayer class and Kotlin

This tutorial will explore how to play and pause audio files in an Android app using MediaPlayer. The first half of this tutorial will focus on how to play audio files which are included within the app itself, while the second half will discuss how to play external audio files and handle errors.

Importing audio files

Sound effects and music that will be used in the app first must be imported into the Android Studio project. To do this, navigate through Project > app then right-click the res folder. Select New > Android Resource Directory

Set the Directory name to ‘raw’ then press OK.

This will create a folder called raw, which is where you will store media files. For this tutorial, we will use an MP3 recording of running water (which you can download below) but you are welcome to use another audio file of your choosing.

Drag and drop the audio file from your computer into the raw folder. Note, you may also be asked to confirm that you wish to move the audio file over to the project.

The water.mp3 file is now ready to be used.

Adding the play and pause buttons

In this section, we will add the play and pause buttons which will control playback. Open up the layout file where you want the buttons to go such as activity_main.xml (found by navigating through Project > app > res > layout). Open the file in Design view and locate the Palette. Search in the Buttons category for the ImageButton widget then drag and drop it into the layout.

A ‘Pick a Resouce’ window will invite you to select an image for the button. Select ic_media_play then press OK to add the button to the layout.

Select the Play button then refer to the Attributes panel. Set the id to ‘playButton’ and the onClick attribute to ‘playSound’. Note the playSound value may not be recognised by Android Studio yet but this will be resolved shortly.

Add another ImageButton like before, except this time use ic_media_pause as the image, set the id to pauseButton and set the onClick attribute to pauseSound. NB: you may have to resolve missing constraints and missing contentDescription errors.

With the play and pause buttons now added to the layout, we can write the Kotlin code which makes the buttons operational.

Making the play and pause buttons operational

To make the buttons operational, open the Kotlin file which manages the layout e.g. MainActivity.kt (found by navigating through Project > app > java > com) then add the following import statements to the top of the file:

Next, declare the following variable before the onCreate function:

The mMediaPlayer variable allows your app to utilise the MediaPlayer class and incorporate audio and video into your app.

Moving on, add the following functions after the onCreate function. We’ll discuss what each function means in turn.

The first function is responsible for playing the water sound. It begins by checking whether or not the mMediaPlayer variable has been assigned an audio file. If it hasn’t, then the MediaPlayer.create(this, R.raw.water) command loads the water.mp3 file and the isLooping = true and start commands begin playing the sound on repeat. On the other hand, if the mMediaPlayer is not null, then this means it has already been assigned an audio file and we can simply resume playback using the start command.

The second function, pauseSound, will only run if the mMediaPlayer variable is not null (i.e. it has been assigned an audio file) and is currently playing audio. If both criteria are met then the pauseSound function will pause playback.

The third function, stopSound, is optional and is included here to show you how you would stop playback as opposed to pausing it. The stop command halts and resets playback of the audio file, while the release() command removes the audio file from the mMediaPlayer variable. Releasing the mMediaPlayer variable when playback stops is good practise because it stops the MediaPlayer class from using the device’s memory and battery unnecessarily.

Finally, the onStop function will run when the activity or app is closed. It checks whether the mMediaPlayer variable has a media file assigned to it. If it does, then the function releases the MediaPlayer class from this file to conserve the device’s memory and battery life.

And that’s it! If you run the app now you should find you can play and pause the water sound on command.

Play external audio files

The MediaPlayer class can also be configured to accept external data sources such as audio files from the user’s device and content from the internet. For example, you load a song from the user’s device as follows:

The above code uses a method called playContentUri to initiate the playback of an audio file based on its Uri (a Uri is a piece of data which locates a file). In addition to loading the audio file using the setDataSource method, the above code also implements a method called setAudioAttributes. The setAudioAttributes method lets you describe the type of content you will be playing. This can be useful in several situations, such as when other apps and hardware interact with your app during playback. The attributes configuration used above specifies that the MediaPlayer will be used to play music. You can explore other attributes such as alarms, speech etc. in the official Android documentation.

Handle MediaPlayer errors

Things can go wrong with the MediaPlayer class from time to time, especially when you are playing external audio files. For example, if your app attempts to play a file which no longer exists then the app could crash if the error is not handled appropriately. One way to handle specific errors is to wrap the MediaPlayer code inside a try/catch block. The try/catch block will «try» a certain task (initiating playback) and «catch» any predefined exceptions (errors). There are two main ways to identify probable exceptions. First, you can test the app yourself and find which exceptions are output in the Logcat when the app crashes (see this tutorial for more information on reading the Logcat). Alternatively, you could read the Android documentation for the methods you are using and find out which exceptions (errors) the method may throw. For example, here is the documentation for the setDataSource method. One of the exceptions it can potentially throw is the IOException. An IOException is caused by an error reading/writing a file and so is likely to be thrown if the app tries to play an audio file which no longer exists. To catch this exception, you could write the following code:

The above code uses a try/catch block to attempt to load an audio file based on its Uri as described in the previous section. In the event that IOException error is thrown, the media player variable is set to null, which essentially removes any data that previously been applied, and the media player is then reset, which prepares the media player to be reused in a new playback attempt.

Источник

Kotlin Android MediaPlayer Tutorial and Examples

Android MediaPlayer Tutorial and Examples.

Here we want to explore some examples regarding the MediaPlayer class using simple step by step examples written in either Kotlin or Java.

Why MediaPlayer?

Mobile devices have these days become many people’s primary source of entertainment. Not only do we use them as our personal assistants which allow us schedule reminders, keep todo lists, shopping and even wish lists, but we also play games and music through them.

Some years back,probably just a decade ago, it was very expensive to find a phone that could do all these. During those days we had feature phones like nokia, sony ericson, alcatel,siemens etc. These phones were not smartphones and didn’t do alot more than calling and sending text messages.

However, these days smarphones are as easy to get as almost anything else. Not just in tier one countries but also in poor countries people have powerful smartphones that can:

1. Access the internet, Send emails, Whatsapp etc.
2. Play media files like mp3 and mp4 songs.
3. Install other apps.

MediaPlayer as a class therefore allows us continue this rich tradition of empowering users. These days we don’t media files only for entertainment but also for educative purposes. Hence this class is one of the most empowering android framework classes that is continuing to revolutionize the tech world.

Example 1: Android Simple ListView MP3 Player Example

In this example we want to see how to create a simple MP3 Player using ListView and MediaPlayer class. We load mp3 files from our external storage and show them in a simple listview. We do this recursively so that we don’t miss songs found in sub-directories. We display the song names in a ListView.

Then when the user clicks a single song in our ListView, we open a new activity, a Player activity and automatically play the song. We will be passing the song path to that activity. Then we use the MediaPlayer class to play the song.

As we play the song we display the a Lottie Animation. When the user will click the back button of our Player Activity, we will continue playing the song. In fact even if we open a new app, that is our app is paused we still continue playing the song.

Here is the screenshot demo of what we create:

1. MainActivity.java

Here’s our MainActivity. The main responsibility of this class is to show our ListView of MP3 songs. To turn it into an Activity we derive from the android.app.Activity class.

Among our imports include the java.io.File as we are reading the file system. Please make sure you add the READ_EXTERNAL_STORAGE
permission in your android manifest.
We also have the android.os.AsyncTask , a class that allows us implement basic threading. In this case we create a simple asynctask to read our songs in the background. We’ve called it the SongsLoaderAsyncTask . AsyncTask is an abstract class so we have to atleast override the doInBackground method. The android.widget.ProgressBar allows us show an indeterminate progressbar as we read our songs into the listview.

android.widget.ListView is our list component. android.widget.ArrayAdapter will be enough for us to adapt our simple data to our listview.

2. PlayerActivity.java

Here’s our PlayerActivity. This activity will play our song. As we play the song we will use the LottieAnimationView to play our animation. Obviously MediaPlayer is the class responsible for playing our mp3 files.

3. activity_main.xml

This is the layout to be used as the user interface for MainActivity . First it will contain a header textview to display our header text. Then below it we have a ListView to render our data in a list. We arrange them linearly using a LinearLayout with vertical orientation.

4. activity_player.xml

This is the layout responsible for showing our LottieAnimationView . We will be showing an animation as our song plays. We wrap a TextView and LottieAnimationView inside a RelativeLayout.

5. AndroidManifest.xml

Add permission to read from songs from external storage

Download

Here are reference resources:

No.	Location	Link
1.	GitHub	Direct Download
2.	GitHub	Browse
3.	YouTube	Video Tutorial
4.	YouTube	ProgrammingWizards TV Channel

Example 2: Android MP3 MusicPlayer with Background Service

This example now shows you how you can play a music player via the MediaPlayer API alongside a Service.

Check the screenshot demo below:

Step 1: Create Project

Start by creating an empty Android Studio project.

Step 2: Dependencies

No external or special dependency is needed for this project.

Step 3: Add Music

In your res directory create a folder known as raw and add your mp3 song inside it:

Step 4: Design Layout

Add two buttons: one to start our music player and the other to stop it, inside the MainActivity layout as shown below:

activity_main.xml

Step 5: Create Music Service

We will be playing our music in a background service. Start by creating a file known as MusicService.java and add the following imports:

Then extend the android.app.Service class:

Declare the MediaPlayer object as our Musicplayer and override the onBind() , in this case to return null:

Now override the onCreate() . Inside it we will create our MusicPlayer by initiating the MediaPlayer using the create() method. We pass the Context as well as the Music Path:

We will the override the onStartCommand() . We will start our MusicPlayer here:

In the onDestroy() callback we will stop our MediaPlayer and release it:

Here is the full code:

MusicService.java

Step 6: Create Activity

We have only one activity: our MainActivity:

MainActivity.java

Copy the code or download it in the link below, build and run.

Reference

Here are the reference links:

Number	Link
1.	Download Example
2.	Follow code author

Example 3: Kotlin Android Audio Player App

In this third example we will write our music player or audioplayer with Kotlin.

Here is what is created:

Step 1: Create Project

Start by creating an empty Android Studio kotlin project.

Step 2: Dependencies

No third party dependency is needed for this project. We however use Kotlin so make sure you’ve created a Kotlin project.

Step 3: Design Music Player Layout

We will do this in our activity_main.xml :

activity_main.xml

We will have an imageview,imagebuttons for navigating to next or previous songs as well as playing or pausing the music, seekbar and textview:

Step 4: Create a SeekBar Handler class

Create the class under the utils and add the following code:

utils/SeekBarHandler.kt

Step 5: Create MainActivity

And add the following code:

MainActivity.kt

Step 6: Add Permission

In your AndroidManifest.xml add the following permission:

Copy the code or download it in the link below, build and run.

Reference

Here are the reference links:

Number	Link
1.	Download Example
2.	Follow code author

Example 4: Kotlin Android MediaPlayer with Adjustable Volume

This is the fourth mediaplayer example for you. It is written in Kotlin and teaches not only how to play the media but also programmatically adjust the volume of the playing music. We will provide a seekbar for this.

Step 1: Create Project

Start by creating an empty Android Studio project.

Step 2: Dependencies

No external dependencies are needed for this project.

Step 3: Add Music

Add a music to your raw folder. If you don’t have such a folder create it inside the res directory.

res/raw/music.mp3

Step 4: Design Layout

Design your MainActivity layout to resemble a music player view or interface using seekbar, imageviews, textviews, buttons etc as follows:

activity_main.xml

Step 5: Play Media

The play/pause button can be used to play or pause the music as follows:

Here’s how a timer label is created for the music player:

Here is how the volume can be adjusted using a custom seekbar:

And here is how we can adjust the music position or seek to a certain period of the music:

Here’s the full code:

MainActivity.kt

Copy the code or download it in the link below, build and run.

Reference

Here are the reference links:

Number	Link
1.	Download Example
2.	Follow code author
3.	Code: Apache 2.0 License

report this ad

Oclemy

Thanks for stopping by. My name is Oclemy(Clement Ochieng) and we have selected you as a recipient of a GIFT you may like ! Together with Skillshare we are offering you PROJECTS and 1000s of PREMIUM COURSES at Skillshare for FREE for 1 MONTH. To be eligible all you need is by sign up right now using my profile .

Источник