Apps für Android programmieren leicht gemacht!
Musik Player Source Code - Teil 1

Musik Player Source Code – Teil 1

Musik Player Source Code – Einleitung:

Wir werden uns in dieser Anleitung einmal der Programmierung eines Musik Players für Android widmen. Unter Umständen wird diese Anleitung etwas umfangreicher und wir werden diese Anleitung höchstwahrscheinlich in mehrere Teile unterteilen. Dir sollte also zu Beginn dieses Artikels klar sein, dass ein Musik Player unter Android nicht unbedingt innerhalb weniger Schritte programmiert ist. Bring am besten etwas Zeit mit.

Natürlich werden wir den gesamten Source Code mit in dieser Anleitung veröffentlichen und zum Ende jedes Teiles mit als Download anbieten.

Zu Beginn erstellen wir am besten erst einmal eine Liste der Funktionen, welche unser Musik Player enthalten sollte. Es ist übrigens immer ratsam vor Beginn der Programmierung eine Liste der nötigen Funktionen zu erstellen. Wir möchten ja nichts vergessen oder uns am Ende ärgern, dass wir falsch programmiert haben.

Die benötigten Funktionen:

  1. Auflisten von Musikdatein auf dem Smartphone.
  2. Anzeigen von Metadaten (Interpret, Album, etc.) der Musikstücke.
  3. Unterteilen der Musikstücke nach Interpret, Album, Genre, etc.
  4. Abspielen und Stoppen von Liedern

Und damit hätten wir auch bereits unsere wichtigsten Funktionen für einen recht simplen Musik Player.

Der Einfachheit halber werden wir diese bestehende Liste, von 1 bis 6 auch gleich als Richtlinie für die weiteren Teile nutzen.
Wir werden also im ersten Teil lernen alle Musikdateien auzuflisten und im sechsten Teil behandeln wir das Abspielen der Musik in zufälliger Reihenfolge.

 

Musik Player – Grundgerüst:

Fangen wir erst einmal an ein einheitliches Grundgerüst unseres Musik Players zu erstellen.
Ich persönliche würde als Application Name „Musik Player“ mit der Company Domain „droid-lernen.de“ bevorzugen, aber das ist euch überlassen. Solltet ihr diese Daten ändern müsst ihr bei den späteren Downloads genau auf den Package Namen achten. Dieser Package Name ist nämlich nach diesen Vorgaben erstellt.

Als Minimum SDK empfehle ich die API 14 zu nutzen. Abgesehen von älteren Tablets sind kaum noch Geräte in Nutzung, die eine API von 14 oder geringer nutzen. Google selber sagt dazu, dass mit API 14 ca. 90,4% der aktiven Geräte abgedeckt sind.

Im vorletzten Einrichtungsschritt unter Android Studio nutzen wir eine Blank Activity.
Der letzte Schritt kann Wortlos übersprungen werden.

Am Ende sollte unsere Klasse MainActivity wie folgt aussehen:

package de.droid_lernen.musikplayer;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;


public class MainActivity extends Activity {

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

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

 

Berechtigung einholen:

Des weiteren benötigen wir ganz dringend eine Berechtigung von Android.
Da wir mit unserer App später einmal alle Musikstücke auf dem Gerät finden möchten, benötigen wir die Berechtigung auf den Speicher zuzugreifen.
Diese Berechtigung holen wir uns von Android, indem wir in die „AndroidManifest.xml“ Datei die Zeile „<uses-permission android:name=“android.permission.READ_EXTERNAL_STORAGE“/>“ schreiben.
Diese Zeile muss innerhalb des Tags „<manifest>“ gesetzt werden. Dies dürfte ungefähr so aussehen:

<?xml version="1.0" encoding="utf-8"?>
<manifest>
    ...
    <application>
        ...
        <activity>
            ...
        </activity>
        ...
    </application>
    ...
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    ...
</manifest>

 

Da wir ab der Android Version 6.0 noch einmal zusätzlich in der App erfragen müssen, ob wir wirklich auf den externen Speicher zugreifen dürfen ist eine Abfrage nötig:
Wir schreiben in die Funktion „onCreate“:

if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {
     // Berechtigung gewährt
     // Hier können wir später dann die Lieder suchen und anzeigen lassen
}else{
     // Berechtigung NICHT gewährt
     // Hole jetzt die benötigte Berechtigung ein
     ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, 1);
}

Damit wir auf eine Bestätigung der Genehmigung reagieren können (nur Android 6.0 und höher) bedarf es folgender Funktion:

public void onRequestPermissionsResult(int requestCode, String permissions[], int[] ergebnis) {
    if (requestCode == 1) {
        if (ergebnis.length > 0
                && ergebnis[0] == PackageManager.PERMISSION_GRANTED) {
            // Berechtigung wurde erteilt.
            // Hier können wir später dann die Lieder suchen und anzeigen lassen
        } else { 
            // Berechtigung wurde nicht erteilt. 
        } 
        return; 
    } 
}

Eine genauere Erläuterung der Vorgehensweise und der Funktionen findet ihr in diesem Artikel: Android 6 – Berechtigung einholen

 

Auflisten von Musikdateien:

Wie bereits in einem vorangegangenen Artikel behandelt werden wir alle Musikstücke des Android Smartphones auflisten müssen.

Dazu erstellen wir uns als aller erstes eine neue Klasse Namens „Lied“.
Diese Klasse sollte dann später alle Informationen zur einfacheren Handhabung beinhalten.
Sie sollte wie folgt aussehen:

package de.droid_lernen.musikplayer;

public class Lied {
    
    private String Titel = "";

    public String getTitel() {
        return Titel;
    }

    public void setTitel(String titel) {
        Titel = titel;
    }
}

Damit können wir innerhalb dieser Klasse bereits den Titel des Liedes in der Variable „Titel“ speichern und auslesen, indem wir die Funktionen „getTitel“ und „setTitel“ nutzen.

 

Im nächsten Schritt können wir eine Liste voller Lieder erstellen, die wir auf dem Android Smartphone finden.
Dazu müssen wir die Liste in der Klasse „MainActivity“ erstellen. Wir fügen folgendes hinzu:

private ArrayList<Lied> LiedListe;

Nun haben wir eine Liste erstellt, die den Datentyp der Klasse „Lied“ enthält. Dadurch können wir bei Verwendung der Liste „LiedListe“ alle Funktionen der Klasse „Lied“ verwenden und auch in dieser Klasse speichern.

Anschließend erstellen wir eine neue Funktion Namens „findeLieder“ und initialisieren die soeben erstellte Liste dort drin.

public void findeLieder(){
    LiedListe= new ArrayList<Lied>();
}

 

Zwar haben wir nun eine Liste erstellt und initialisiert, aber bisher ist sie noch leer. 🙁
Das möchten wir nun gerne ändern und greifen dabei auf eine in Android bestehende Funktion zurück uns alle Daten vom Typ „Audio“ ausgeben zu lassen.
Diese Funktion gibt uns einen Cursor zurück, welchen wir darauf hin nur noch auslesen müssen.
Wir fügen in die Funktion „findeLieder“ diesen Code hinzu:

ContentResolver musicResolver = getContentResolver();
Uri musicUri = android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
Cursor LiedCursor = musicResolver.query(musicUri, null, null, null, null);

if(LiedCursor!=null && LiedCursor.moveToFirst()){
            
     int titleColumn = LiedCursor.getColumnIndex(android.provider.MediaStore.Audio.Media.TITLE);
            
      do {
          String thisTitle = LiedCursor.getString(titleColumn);
          LiedListe.add(new Lied(thisTitle));
       }
       while (LiedCursor.moveToNext());
}
    }

Und schon haben wir eine Liste voller Lieder, die sich auf unserem Smartphone befinden.

 

Anzeigen der Liste:

Leider sehen wir von dieser Liste bisher wenig, also sollten wir uns im letzten Schritt noch einmal daran machen diese Liste anzeigen zu lassen.

Dazu fügen wir bitte eine ListView mit der ID „LiedListView“ in unser Layout „activity_main.xml“ hinzu.
Das sollte so oder so ähnlich aussehen:

<ListView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/LiedListView"
        android:layout_alignParentTop="true"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true" />

 

Weiter geht es mit einem neuen Layout, dieses beschreibt das Aussehen der einzelnen Einträge in unserer Liste. Wir nennen dieses Layout am besten einmal „lied_eintrag.xml“ und machen ein „RelativeLayout“ daraus. Dieses RelativeLayout hat den Vorteil, dass wir Elemente innerhalb dieses Layouts beliebige platzieren können, ohne an Regeln gebunden zu sein.
Innerhalb dieses neuen Layouts erstellen wir eine einfache TextView Namens „LiedTitel“. In diesem TextView lassen wir uns dann den Titel des bestimmten Liedes anzeigen.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent" android:layout_height="match_parent">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceMedium"
        android:text="Medium Text"
        android:id="@+id/LiedTitel"
        android:layout_alignParentTop="true"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true" />
</RelativeLayout>

 

Schließlich erstellen wir noch einen Adapter, der die ListView mit Hilfe des Aussehens des „lied_eintrag.xml“ Layouts befüllt.

package de.droid_lernen.musikplayer;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.RelativeLayout;
import android.widget.TextView;
import java.util.ArrayList;


public class LiedAdapter extends BaseAdapter {

    private ArrayList<Lied> lieder;
    private LayoutInflater liedInf;

    public LiedAdapter(Context c, ArrayList<Lied> lieder){
        this.lieder = lieder;
        liedInf = LayoutInflater.from(c);
    }

    @Override
    public int getCount() {
        return lieder.size();
    }

    @Override
    public Object getItem(int arg0) {
        return null;
    }

    @Override
    public long getItemId(int arg0) {
        return arg0;
    }

    @Override
    public View getView(int arg0, View arg1, ViewGroup arg2) {
        
        RelativeLayout songLay = (RelativeLayout)liedInf.inflate(R.layout.lied_eintrag, arg2, false);
        
        TextView songView = (TextView)songLay.findViewById(R.id.LiedTitel);
        
        Lied momentanesLied = lieder.get(arg0);

        songView.setText(momentanesLied.getTitel());

        songLay.setTag(arg0);
        
        return songLay;
    }
}

 

Schlussendlich müssen wir die Funktion „findeLieder“ in eine neue Funktion „findeLiederUndFuelleListe“ einfügen, dass diese so aussieht:

public void findeLiederUndFuelleListe(){
    findeLieder();
}

Und nur noch den folgenden Code am Ende der Funktion „findeLiederUndFuelleListe“ einfügen:

LiedAdapter liedAdapter = new LiedAdapter(this, LiedListe);
ListView liedListView = (ListView)findViewById(R.id.LiedListView);
liedListView.setAdapter(liedAdapter);

 

Erinnert ihr euch noch an die beiden Kommentare „// Hier können wir später dann die Lieder suchen und anzeigen lassen“ ?
Diese Kommentare könnt ihr nun durch den Funktionsaufruf „findeLiederUndFuelleListe();“ ersetzen.
Diesen ganzen Blödsinn müssen wir machen, weil ab der Android Version 6.0 eine zusätzliche Berechtigungsabfrage erfolgen muss, bevor wir die Funktion „findeLieder()“ ausführen dürfen.
In einer Android Version von unter 6.0 würde eine frühzeitige Ausführung von „findeLieder()“ kein Problem darstellen.
Unter Android 6.0 und höher würde unsere App jedoch abstürzen, da wir versuchen alle Lieder auf dem externen Speicher zu suchen, aber noch gar keine Berechtigung haben auf den externen Speicher zu zu greifen.

 

Damit wäre unser erster Schritt Richtung eigenem Musik Player getan.
Viel Spaß beim Nachprogrammieren, während wir den zweiten Teil der Anleitung für euch fertig schreiben.
Den Source Code dieses ersten Teiles könnt ihr bereits jetzt hier downloaden.

Musik Player Source Code - 1


Lade dir den Source Code für diesen Musik Player kostenfrei herunter. Alle beschriebenen Schritte dieses Teiles des Anleitung zum ausprobieren, tüfteln und verändern.

DownloadLizenzbedingungen

Marvin

Ich bin 23 Jahre jung und studiere zurzeit Wirtschaftsinformatik an der Georg-August-Universität in Göttingen. Ich bin ein Mensch, der sich neben der Programmierung noch für tausend andere Dinge interessiert, die mal mehr und mal weniger verrückt sind. Vor allem aber bin ich Feuer und Flamme mit der Programmierung von eigenen kleinen Apps und Programmen, die mein Leben bereichern.

4 Kommentare

*Pflichtfeld

  • gibt es auch einen fertiges Programm, mit dem man Musikplayer Programmiren kann? Ich kann nämlich kein Java o.Ä. un bin daher in der Sache aufgeschmissen

    • Hallo Ben,

      nein, so eine Software gibt es meines Wissens leider nicht.
      Es wird wohl kein Weg daran vorbei führen sich ein wenig mit der Programmierung auseinander zu setzen.

      Gruß,
      Marvin

  • Servus,

    kurze Frage, ich bin neu unter den Android Programmierern und wollte kurz fragen, wie ich hier anfange? Wähle ich ein ein template aus oder starte ich komplett „naked“ mit der Programmierung? LG