android studio android studio tutorial code android music player Teaching Online tech Tutorial uthena

Code Your Own Video App Player in Android Studio!

Code Your Own Video App Player in Android Studio!

Good day and welcome to this new Android Improvement Tutorial. This is half one on find out how to make a music participant for Android. Let’s start. We begin by opening Android Studio, then we’ll click on start a new Android Studio venture, then we’ll click on on empty exercise, after which on the subsequent button.

As the identify of this software, we’ll write ‘Music Participant’. We’ve the identify. Make it possible for the language you choose is Java and the minimal API degree this time we’ll choose 14. In fact, we will change this later if we have to.

We’ll click on on end and we’ll watch for the IDE to setup our Android Studio undertaking. The Android studio venture is now being set up by the Android Studio IDE so we’ll await it. I will even need to inform you that I shall be operating the appliance on an emulator within the left aspect of the display.

You can do it in an emulator too if you would like or you’ll be able to truly run it on an actual android gadget. What we now have to do on this music participant software is actually fairly easy. We need to read the storage of the gadget and discover music information, and then listing them on an inventory view with its respective adapter. Then we’ll allow the consumer to play those information .

If you will take pleasure in studying and contributing to the discussion for this submit, will you please be a part of us on the YouTube video above and depart a comment there because I learn and respond to most feedback on YouTube?

When you discover something helpful in this video or humorous, will you please depart a like as a result of you will really feel great serving to other individuals discover it?


The IDE has completed loading the venture and the very first thing we’ll do is we’ll change the format file that comes as default.

We’ll go to the left aspect, we’ll open the res folder, after which we’ll open the format folder. We’ll right click on on the activity_main.xml file, and we’ll click on delete. We’ll be sure these both bins are unchecked, and then we’ll click in okay.

The file is being deleted as you possibly can see and what we’ll do now, we’ll create a new file but with a special root factor. For that, we’ll go again, to the format folder, we’ll right click on it, then we’ll click on on a new Format useful resource file.

As file identify we’ll write activity most important, so the identical identify it had previously, however on root factor we’ll delete the default worth, and we’ll sort linear format. We’ll press on OK and we’ll watch for the IDE to generate a code.

As you possibly can see this is the code the IDE generated. In order for us to truly take a look at the code you will click on on the text view mode right right here, and as you’ll be able to see we have now our linear format prepared to be used.

Proper now simply verify if every thing works okay. I will ship the app to the emulator, and be sure that every little thing seems as we would like. These file will allow us to set up how we would like the appliance to look. This is the XML file, the format file. The Java file will allow us to set how the appliance behaves.

The emulator is being initialized proper here so we now have to wait a few minutes for it in addition up, and to run the app. As I used to be telling you, we now have these file which allows us to create the consumer interface of our Android software, and if we add ids to the weather of those interface we will then retrieve these parts utilizing their ids from the code which is the file proper right here.

We’ll anticipate the app to run and we’ll examine if it is displaying the suitable content material. I will change to the emulator right here and I will anticipate it as well up. As you possibly can see it says ‘telephone is a starting’.

This emulator is operating Android P, Android Pie. Android model which is API 28. It’s the newest one as at the time of recording this video. As you’ll be able to see the app must be virtually ready. As you possibly can see there’s two processes operating proper here which is the Gradle Construct operating. We have now this updating indices.

Let’s see. Now, it’s installing the appliance. Nice. If we go to the emulator we will see that we’ve got our app right here and it’s truly working as we anticipate.

It’s empty as a result of we haven’t actually added something to it. Proper now, we’ll change again to the Android studio IDE and what I need to do now’s to delete these two bars as a result of we would like sort of a cleaner look of our software.

We would like it utterly widescreen.

To cover these two bars what we’ll do is we’ll go underneath the res folder, after which underneath values folder, and it’ll open the types.xml file.

Right here we will customise the actual theme of the appliance. For that, we’ll go inside the styled brackets and we’ll sort merchandise identify, and we’ll sort window full display, and we’ll set this value to true.

What that’s doing it’s hiding the highest bar. What we’re going to do is, we’re going to cover the title, so you’re going to say is window no title. We may also set this to true.

With these two strains I simply wrote we’re hiding each of the 2 bars we noticed within the emulator. To examine if it works I will run the app once more and ensure that it seems to be as we would like. It’s been put in. It’s operating right now and as you’ll be able to see it’s empty. Every thing is empty simply as I would like it to be.

We will transfer on to Android Studio IDE and we’ll shut this type.xml file.  We’ll open the Gradle script file that may allow us to customize and clean up it a bit extra. We’ll open the second one which is the construct.gradle file which is a module app. Be sure to open the second. The one that says module app. We open this and this is sort of an abstraction degree during which we set the configuration for our software.

This can be a simple software. We’re simply learning. We will simplify this file much more so you possibly can truly by having an easier view of it, you’ll be able to truly perceive what’s happening.

This line is for testing.

We gained’t be testing it with utilizing the unit tester library, so we will delete this line. These brackets – these BuiltTypes bracket – we don’t need it. We don’t need it because we aren’t deploying it and we don’t have custom configurations for it.

Listed here are the dependencies.

There’s a variety of stuff that we don’t actually need about this. The only one we’d like is this one – the appcompat library. So we will delete all the others but not that one. We’ll delete all these. As you possibly can see now the file is a lot more easy and easier to read.

What that is saying principally, is we’re utilizing API 28 to compile the appliance. The minimal SDK we’re concentrating on is 14 and the target is 28. The model code of the app is 1 and the model identify 1.0. The one dependency we’re using is the appcompat1.

After we’ve got modified these we’ll click on sync now right here at the prime. When you don’t find that button it’s also possible to click on these elephant button that chosen with the mouse pointer.

We will additionally close this file. To ensure all the things works once more, I will run the app once more and verify that it nonetheless works high-quality. Let me see. I’m installing the app and I’m operating and it nonetheless work high quality.

Let’s truly begin with the coding of our software.

Great. The very first thing we’ll do is we’ll work on the format file of our software. As I advised you the format file allows us to create UI parts using the XML type of scripting language. After we do this, we will access the code from Java.

Let’s start working on it. We’ll go to activity_main.xml file and since what we need to do is record the music information or the audio information, type of mp3 information that exist on the system storage, we’ll use a ListView.

We’ll open an element and sort ListView.

The width of this component will probably be match_parent. The height shall be 0DP and the load can be 1. We will close this here to make it more clean to see. We’ll add an ID to this object, so we’re going to sort ID and we’ll call it ListView.

We now have added an inventory view proper right here. Aside from listing the music information, we need to type of, in fact, play the music file, and perhaps present controls of perhaps cease and play the file again. We will implement that later. For now, that is the one thing we’ll add. Later we will complete this file. We’ll change back to our foremost and right here we’ll start studying what’s happening.

As default the IDE generates for us this file and provides the onCreate() Technique during which the one factor it does is it set the content material view to our XML file. We are reading information from this storage – from the gadget storage – and the Android operating system requires us to ask for permission beginning in API 23 or Marshmallow and above.

To ask for permission we’ll go to our manifest file proper right here, we’ll open this.

As you’ll be able to see, we’ve got a warning. We will ignore that by clicking and suppress the warning if you would like.

We even have here the activity definition. The orientation of the exercise will probably be portrait so we going to say display orientation and set that to portrait.

Aside from that, we’ll sort the appliance tag and we’ll open the uses-permission factor. The primary one shall be set to read external storage. We’re reading the exterior storage proper here which is the permission we’d like in order for our software to run.

Once we have now outlined the permission on the androidmanifest.xml file, we will go to our most important file and truly start initializing every little thing we would like our software to do. To start with, we have now to be able to examine permissions at runtime as I informed you in Android 23 – apk23 or  Marshmallow. We’re required to do exactly that.

To try this we’ll do the next. After the onCreate() technique, we’ll outline the permissions we need to ask. For that we’re going to sort Personal static final_String[]. We’ll define the permissions as an array of strings and we’ll call this PERMISSIONS. Keep in mind to end the road with a semicolon and right here we’ll specify the precise permissions our app requires.

To specify the permissions we’ll do the next;- we’ll sort manifest.permission.READ_EXTERNAL_STORAGE.

This is the permission we’d like. It says that area requires API degree 16. To repair this warning we’ll go to our construct.gradle file we opened beforehand. The one we have now simplified. We’ll change the minimal SDK version from 14 to 16.

We’ll click on sync now, we’ll anticipate the sync to be accomplished. We will close this file, return to our fundamental and we will see that the warning has disappeared which is superior.

Now, that we’ve got outlined the permissions we would like, we also need to define a request code, so we will know which permission we requested, and type of control the move of the permission request process. To try this we received to say and create the following variable.

Personal static last int. We’ll name this REQUEST_PERMISSIONS. Here we now have to enable or assign this int and a sort of a singular ID. It doesn’t actually matter. Perhaps I’ll tell it to be one, two, three, 4, 5. It’s truly any number you need.

Lastly, we’ve got to define a variable an Int variable once more, that may retailer the quantity of permissions we are requesting. On this case, it’s only one. We’ll name this PERMISSIONS _COUNT. We’ll set this to 1.


As default in some units the permissions are routinely granted, but in different’s they don’t seem to be. We’ll examine if the permissions are denied by creating the following technique. We’re going to say personal boolean arePermissionsDenied. You’ll open these technique and we’ll create a for loop as follows. We’re going to say for int I=0:  I <_PERMISSIONS _COUNT. We'll say I++.

We open the For loop and we write the next logic. We’ll verify if the permissions are granted or not. To that we’re going to say if checkSelfPermission and because the parameter we’ll cross PERMISSIONS at I. We access the string array of the permissions, and we’re pointing to the component I. If permissions at I is totally different, if checkSelfPermission at I is totally different then PackageManager.PERMISSION_GRANTED. So if it’s totally different than permission granted, we’ll return true which can inform us the permission has been denied. After we run this for loop and if it hasn’t returned, we’ll return false which suggests permissions usually are not denied. Which suggests they’re granted.

As you’ll be able to see we now have a warning proper here on the examine self permissions line which says call requires API degree 23, but we will probably be calling this solely in API degree 23, so we will ignore this by clicking on this warning sign, and then suppress hyperlink new API annotation.

We click on that and this line is added and now, the warning is gone. That’s it for this technique here. We’ll continue proper now and after the consumer checks or clicks on permit or deny permission what we’ve to do is get the results of that permission. If the consumer allowed it or denied.

To try this, we’ll do the following. We’ll override public void onRequestPermissionsResult(). Inside this, we have now some parameters which are passed. The first one can be an int which can move the requestCode. So you’ll be able to say int requestCode. The second might be a string array and we now have the permissions we have been asking for. So, permissions and we also have an int array that may return the results of those permissions. So we will call it grantResults.

We’ll open the tactic and we’ll call the super technique.  We’re going to say super.onrequestpermissionsresult, and we’ll cross the same parameters we receive. So the primary one will probably be requestCode then will probably be permissions, and then can be grantResults. Great.

Now, we will make our lives easier through the use of the previous technique, we wrote which is arePermissionsDenied, so we’ll verify it right right here. We’re going to say if arePermissionsDenied which means the consumer has denied the permission. If that permission is a should the app can’t work with out it. So if the consumer denies the permission we need to clear the appliance knowledge, and close the app which can allow us to maintain asking for the permission every time the consumer opens the app again.

To accomplish that, we’ll do the next. We’ll open two parentheses and the first one we’ll write ActivityManager. Outdoors the first one, we’ll create one other parenthesis. The ActivityManager is type of the casting object, that we’re casting into. Inside these second parenthesis, we’ll sort this.getSystemService. Because the parameter of this we’ll cross ACTIVITY_SERVICE. We go after the three parentheses and we sort .clearApplicationUserData, and this is principally the road that may clear the info right here.

We have now ActivityManager, getSystemService(ACTIVITY_SERVICE). We then sort clearApplicationUserData. Once more, this warning must be silence because we’re calling solely once we should. We’re going to go and say suppressLint new API annotation and the warning is gone.

In that case, what we’ll do is we’ll recreate the exercise after that.

The primary document is when the consumer denies exercise, and when the consumer allows the permission, we need to call the onResume technique as a result of in that technique we’ll do all the initialization. We just sort on resume and we’ll depart it there.

We’ve principally created our primary technique proper right here, so now let’s override the onresume technique. We’re going to go and say @override protected void onResume. Inside the tactic we’ll call the super technique. Super.onResume and inside right here what we’ll do is we’ll verify if we’ve to requests or not the permissions.

To try this we’ll do the next, we’ll go and sort if Build.VERSION.SDK_INT >= Construct.VERSION_CODES. M which suggests marshmallow. If this assertion is true, we additionally will verify if the permissions are denied. To examine the permissions are denied, we’ll say && arePermissionsDenied. So we name the tactic. If these two circumstances are true we’ll request for permissions. To try this we going to sort requestPermissions and as the first parameter will cross PERMISSIONS which is our array of permissions, and a second one will be the requestCode which is the REQUEST_PERMISSIONS variable.

After this, we’ll return because we don’t need to maintain initializing if we don’t have the required permissions. Right now, we’ve got our primary sort of app that ask permission so to examine that every little thing works as we would like, we’ll run the appliance to verify if it truly works as expected. Now, I’m compiling the app and sending it to the emulator. Emulator runs the app and as you possibly can see it appears this dialog that claims ‘Permit music participant to entry photographs, media, and information in your gadget?’ Here the consumer can click either deny or permit.

If the consumer clicks on deny then the app is closed and the appliance knowledge is cleared. If the consumer goes once more on the music participant software it asks once more. So the consumer can hold denying, and maintain opening the app. The consumer can maintain opening the app.

Principally what we did on this tutorial is we setup the Android studio venture, we simplified the format file, we simplified the Gradle build file, and we’re requesting the permissions in the Android manifest, and in addition on code. I’ll run the app again. Click music participant. So as you possibly can see it retains asking until the consumer allows the permission.

I’ll click on permit and as you’ll be able to see now the app stays opened which is nice. If we return to our IDE and we continue wanting on the code, we will see on the on resume technique on the return, we now have a warning right right here that says return is pointless as the final statement in ‘void’ technique which is true however that gained’t be the final assertion as a result of we’ll hold writing some stuff right here.

What we’ll do now’s start initializing the music player. For that, we’ll create a worldwide variable that might be personal boolean isMusicPlayerInit which suggests is music player initialized? As default, in fact, that shall be set to false and proper right here contained in the onResume() technique we’ll examine for that flag, so we’re going to sort if !isMusicPlayerInit which suggests if music player just isn’t initialized then we’ll initialize the music participant.

Proper right here, the very first thing we’ll do is change the flag. The last assertion of this if bracket, we’ll go and say isMusicPlayerInit and we’ll set this to true. Superior.

Should you keep in mind on the activity_main.xml file we created a ListView so we’ll entry this ListView right now from the Java code. To entry the ListView we’ll do the next. We go and say remaining ListView and we’ll call it ListView, and we’ll set this to seek out view by Id. Great. Proper now we’ve got created our ListView. We’re accessing this ListView from code which is great.

In the subsequent half we’ll discover ways to set up this ListView and create a parameter.

We’ll read information and every little thing else we require to make this app working. In this part we’ll continue to work on the appliance. Proper now, we go to our onResume() technique and right here within the verify through which we examine if the music player is initialized, within the previous part what we did here is that we set the ListView to the component of our manifest file.

The subsequent factor we’ll do is to truly create an adapter for our ListView. We’ll go outdoors the onResume() technique and we’ll sort class. We’ll name this class TextAdapter and we’ll prolong BaseAdapter.

We’ll open this bracket right right here and we’ll create the next technique that may allow us to set the info of the adapter. To begin with we’ll create an array record that may include the info. For now, we’re going to sort personal record of strings, and we’ll name this knowledge, and we’ll set these to new array listing. Don’t overlook to import the listing library.

We now have our knowledge array listing just created and now we are going to set and create a way that may enable us to set the info of that array listing. We’re going to sort void setData. We’ll open these technique proper here, and what we’ll do is first we’ll clear the previously knowledge that existed on that array record. For that we’re going to say knowledge.clear. Next what I will do is knowledge.addAll.

What we’ve got so as to add is the brand new knowledge so we now have to create a brand new parameter inside setData technique definitions. Proper right here, you possibly can say listing of string and we call this mData.

Inside this addAll what we’ll do is sort mData. Nice.

After we’ve got updated the info set we have been going to notify that it was up to date, so that you’re going to say notifyDataSetChanged. Great.

That was our setData technique. We’ll continue writing the subsequent technique. The primary one will override would be the getCount technique. We’re going to say override public int get rely. We’ll open this and what we’ll return that needs to be an int would be the measurement of our knowledge set. So I acquired to say return knowledge.measurement.

That’s our getCount technique. Subsequent, we’ll override the getItem technique. So we will say @override public object, getItem, and as parameter we’ll get place.

As an alternative of object we’ll truly change this to string because perhaps we need to use this if we’d like it. We’ll open this technique proper right here and we’ll return null for now, proper? As a result of I don’t assume we’ll want it for now. Later if we’d like it we’ll return what we’d like.

We’ve to additionally override the getItemId technique, so you’ll be able to say public long getItemId. The parameter of those will probably be int place as properly. We’ll open these and as soon as again, will return null because we gained’t be returning something proper right here, however we have now to override it.

We can’t return null apparently so we’ll return zero. Nice.

That’s getItemId and now, we’ll override the last technique which can also be crucial one which is the getView technique. Public view, import view library, then name getView. The parameters of this technique might be as follows;- the first one int position – the place of the view. The subsequent one shall be view convertView – which is the view we’re getting – and the third is the view group, so viewGroup. You will name it father or mother.

We’ll open this technique and we have now to, in fact, return a view right right here. To begin with, we’ll examine if convertView is null in order for us to initialize it. You possibly can say if convertView is null what we’re going to go goes to open this bracket proper here, and if it’s null, we’ll do the following. We’ll get the view and inflat it however before we do this, we’ve got to truly create that view in code – in XML code truly.

So to try this we’ll go and open our res folder right here at the left aspect of the display. Then the format folder.

We’ll right click on on the format folder, then on new, and the format useful resource file. In file identify we’ll call it item and as root aspect we’ll put a textual content view as a result of we shall be displaying textual content, right?  Ensure you have merchandise and text view, after which click in OK.

As you’ll be able to see the IDE generates this file for us. We’ll change to the text mode right right here, and we’ll modify these a bit. As you’ll be able to see the width and peak parameters are already set. We also need to set an ID to those textual content view gadgets, so we’re going to say ID perhaps myItem. We’re going to set the gravity. We would like the textual content to seem in the middle so we’re going to say gravity shall be set to middle vertical.

Then we’re going to sort of change the textual content measurement a bit. For this case, I feel it might be  20 sps something like that. That’s good. Textual content measurement 20 SP. We will change that later, in fact. We will even add a padding to the beginning to ensure that us to type of take a look at it in a less difficult method, so we’re going to say padding begin. We’re going to set this to 16 DP. Right here we’re have a type of warning that tells us that we also needs to set padding left, so we’ll do this too. Padding left we will even set this to 16 DP which is nice.

It says that we now have additionally defined padding right and paddingEnd, so we’re going to try this. PaddingEnd again 16 DP and in addition padding proper additionally 16 DP. As you’ll be able to see the warnings at the moment are gone. Nice.

Now, what we’ll set the textual content shade to shall be black. So I’m going to go and say text shade, to set it to black we’re going to write down quantity signal # adopted by six zeros and I feel we’re able to go now, right? Superior.

We’ll return to our principal file and we’ll continue to put in writing our getView technique now, that we’ve got created the merchandise on the XML file. If convertView is null what we’ll do is convert view equals to ayoutInflater.from, we open parentheses and we sort father or mother.getContext. Outdoors this we’re going to press dot. I will do it in the subsequent line. Get the context.inflate and we’ll inflate the format right right here, so will probably be R.format.merchandise. That will be the first parameter. The second one will be the mother or father or the basis so we’re going to move mum or dad, and the third shall be hooked up to root. In this case, we’re going to move it false.

We have now set our convert view variable proper here and I may even set the tag that may allow us to get it’ll later once we need to set the textual content to the view. You bought to say convert view.set tag and because the tag we’ve obtained to say new Viewholder. We don’t have the viewholder so we’ve to create the viewholder class. You got to go outdoors this getView technique just right here. We’re going to sort class ViewHolder and inside this technique we’re going to do the next. We’re going to create a text view. We’ll call this text view information, for example. You possibly can have any identify really and as the constructor technique you’re going to say ViewHolder. The parameter, the first one can be the only one truly textview. I’ll name it mInfo and I will open these right right here and I will set information is equal to mInfo and that’s it for this class.

We will return to convertView.setTag line, we have been previously, and now we will entry the ViewHolder class that we create as you possibly can see.  Now right here we’ll open parentheses after this ViewHolder definition. We’ll open parentheses again to forged in textview and out of doors this, we’ll sort convertview.findviewbyID, and this ID we’ll sort

Proper now, that’s it for when the convert view is null. Outdoors this if bracket we’re going to create a holder . You possibly can say ViewHolder we’ll call this holder and we’ll forged this to ViewHolder, and we’ll set this to convertView.getTags. We’re getting the tag we set beforehand. Here we’re going to get the merchandise that we need to display.

You’ll be able to say ultimate string, call it merchandise and what we’re going to do is knowledge.get(position). Which is great. We now have our item and our holder. We’ve got to now set the textual content view.


Would you wish to proceed studying about the Code Your Personal Music Player App in Android Studio Course? In case you are interested will you please buy the entire course, Code Your Own Music Player App in Android Studio, on the Uthena Schooling Platform..

You may also get the first hour and forty minutes of the course utterly totally free on YouTube.

Thank you for studying the weblog publish or watching the course on YouTube.

I really like you.

You’re awesome.

Thanks very much for testing the Code Your Personal Music Participant App in Android Studio Course and I hope to see you once more in the subsequent weblog publish or video.


Jerry Banfield.