Android App mit einer MySQL Datenbank verbinden (16.01.2016)

In diesem Tutorial möchte ich gerne mein bestehendes Tutorial “Android App mit MySQL Datenbank verbinden” erweitern und mit einem konkreten Beispiel verfeinern.

Das bestehende Tutorial dient dabei als Grundlage (es ist jedoch keine Voraussetzung dieses zu kennen.).

Entwicklungsumgebung

Als IDE verwende ich das Android Studio.

Diese kann unter folgender Adresse “http://developer.android.com/sdk/” heruntergeladen werden (ca. 1.1 GB ohne Updates).

Nachdem die IDE installiert wurde und ggf. die Updates für die neuen Android-Versionen eingespielt wurden, kann ein neues Projekt erstellt werden.

Erstellen des Android Projektes “SimpleMySQLConnectionApp”

Als Erstes muss man das Projekt in der IDE erstellen, dieses geht am einfachsten mit dem Wizard welcher einen durch die Fenster führt.

In diesem Fenster wählen Sie den Menüpunkt “Start a new Android Studio project”.

Geben Sie hier nun

• Application name – der Name der Android Anwendung
• Company Domain – dieses wird unser default Pakage
• Project location – Ablageort der Sourcen
  • dieser Pfad darf nicht zu lang und
  • es dürfen keine Leerzeichen im Pfad benutzt werden

ein.

Als Zielplattform verwende ich mindestens die Android-Version 4.4.
In diesem Dialog könnte man noch andere Plattformen definieren, welches für dieses Tutorial jedoch zu viel Overhead erzeugen würde.

In diesem Dialog kann das Aussehen der App definiert werden, zbsp. kann man hier auch wählen das Tabs verwendet werden oder man kann eine fertige Vorlage (Login Activity) erstellen lassen.

Ich wähle hier eine leere Activity da es für dieses Beispiel nur eine Ausgabe auf der Activity geben soll.

In diesem Dialog geben Sie

• Activity Name – der Name der zu erstellenden Activity ein
  • späterer Dateiname der *.java Datei
• Layout Name – der Name der Layout Datei
  • späterer Dateiname der *.xml Datei
• Titel – der Titel der Anwendung
• Menu Resource Name – Name des Menüs welches für diese Activity angelegt werden soll.

Nachdem alle Eingaben  getätigt wurden und der Wizard mit der Schaltfläche “Finish” beendet wurde, wird das Projekt angelegt. Je nach Rechner kann dieses etwas dauern.

Es kann ggf. vorkommen das die IDE eine Fehlermeldung nach dem Starten erzeugt, dieses liegt in den meisten fällen daran dass, das Kompilieren des Projektes noch nicht abgeschlossen ist und somit noch nicht alle Sourcen zur Verfügung stehen.

Erstellen der Datenquelle für die Activity

Die Datenquelle für die Activity wird wie folgt erstellt.

Erstellen der Datei “ActivityDataSource.java”

Es wird eine Java Klasse erstellt (vorzugsweise in einem separaten Pakage) welche die abstrakte Klasse AsyncTask erweitert. Die abstrakte Klasse AsyncTask zwingt einem nun die Methode “doInBackground” zu implementieren, welche wir später für das Lesen der Daten benötigen.

public class ActivityDataSource extends AsyncTask<String, Void, String> {

    @Override
    protected String doInBackground(String... params) {
        return null;
    }
}

App Berechtigungen einstellen

Für die nächsten Schritte müssen die App Berechtigungen eingestellt bzw. verändert werden. Dieses wird für die Benutzung des Internets bzw. des Netzwerkes benötigt.

Die Berechtigungen (auf Englisch “permission”) werden in der Datei “AndroidManifest.xml” gesetzt (siehe Grafik.)

Berechtigung zum Zugriff auf das Internet

<uses-permission android:name="android.permission.INTERNET" />

Berechtigung zum lesen des Netzwerk Statuses

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Erstellen der Methoden zum verbinden zur Schnittstelle

Folgende Methode erstellt die URL mit den benötigten Parametern und öffnet eine Verbindung zu dieser mit einer URLConnection.

/**
     * Öffnet eine Verbindung {@link URLConnection}.
     * @throws IOException
     */
    private void openConnection() throws IOException{
        //StringBuffer für das zusammensetzen der URL
        StringBuffer dataBuffer = new StringBuffer();
        dataBuffer.append(URLEncoder.encode("authkey", "UTF-8"));
        dataBuffer.append(POST_PARAM_KEYVALUE_SEPARATOR);
        dataBuffer.append(URLEncoder.encode(AUTHKEY, "UTF-8"));
        dataBuffer.append(POST_PARAM_SEPARATOR);
        dataBuffer.append(URLEncoder.encode("method", "UTF-8"));
        dataBuffer.append(POST_PARAM_SEPARATOR);
        dataBuffer.append(URLEncoder.encode(DESTINATION_METHOD, "UTF-8"));
        //Adresse der PHP Schnittstelle für die Verbindung zur MySQL Datenbank
        URL url = new URL("https://draeger-it.blog/smssca/reader.php");
        conn = url.openConnection();
        conn.setDoOutput(true);
        OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
        wr.write(dataBuffer.toString());
        wr.flush();
    }

Lesen des Ergebnisses aus der geöffneten URLConnection

Im vorherigen Schritt haben wir eine Verbindung geöffnet und einen Befehl abgesetzt, unsere PHP Schnittstelle hat aus diesem Befehl einen Output generiert welchen wir nun lesen und ggf. parsen können / müssen.

/**
     * Ließt das Ergebnis aus der geöffneten Verbindung.
     * @return liefert ein String mit dem gelesenen Werten.
     * @throws IOException
     */
    private String readResult()throws IOException{
        String result = null;
        //Lesen der Rückgabewerte vom Server
        BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        StringBuilder sb = new StringBuilder();
        String line = null;
        //Solange Daten bereitstehen werden diese gelesen.
        while ((line = reader.readLine()) != null) {
            sb.append(line);
        }
        return sb.toString();
    }

Die gesamte Klasse “ActivityDataSource.java”

Hier nun die gesamte Klasse.

Im Konstruktor wird hier ein TextView Objekt erwartet welches im letzten Schritt “onPostExceute” befüllt wird.

package smssca.stefandraegersoftware.de.simplemysqlconnectionapp.datasource;


import android.os.AsyncTask;
import android.widget.TextView;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;

public class ActivityDataSource extends AsyncTask<String, Void, String> {

    public static final String AUTHKEY = "test321";

    public static final String POST_PARAM_KEYVALUE_SEPARATOR = "=";
    public static final String POST_PARAM_SEPARATOR = "&";

    private static final String DESTINATION_METHOD = "allEntrys";

    private TextView textView;

    private  URLConnection conn;

    public ActivityDataSource(TextView textView) {
        this.textView = textView;
    }

    @Override
    protected String doInBackground(String... params) {
        try {
            openConnection();
            return readResult();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * Öffnet eine Verbindung {@link URLConnection}.
     * @throws IOException
     */
    private void openConnection() throws IOException{
        //StringBuffer für das zusammensetzen der URL
        StringBuffer dataBuffer = new StringBuffer();
        dataBuffer.append(URLEncoder.encode("authkey", "UTF-8"));
        dataBuffer.append(POST_PARAM_KEYVALUE_SEPARATOR);
        dataBuffer.append(URLEncoder.encode(AUTHKEY, "UTF-8"));
        dataBuffer.append(POST_PARAM_SEPARATOR);
        dataBuffer.append(URLEncoder.encode("method", "UTF-8"));
        dataBuffer.append(POST_PARAM_KEYVALUE_SEPARATOR);
        dataBuffer.append(URLEncoder.encode(DESTINATION_METHOD, "UTF-8"));
        //Adresse der PHP Schnittstelle für die Verbindung zur MySQL Datenbank
        URL url = new URL("https://draeger-it.blog/smssca/reader.php");
        conn = url.openConnection();
        conn.setDoOutput(true);
        OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
        wr.write(dataBuffer.toString());
        wr.flush();
    }

    /**
     * Ließt das Ergebnis aus der geöffneten Verbindung.
     * @return liefert ein String mit dem gelesenen Werten.
     * @throws IOException
     */
    private String readResult()throws IOException{
        String result = null;
        //Lesen der Rückgabewerte vom Server
        BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        StringBuilder sb = new StringBuilder();
        String line = null;
        //Solange Daten bereitstehen werden diese gelesen.
        while ((line = reader.readLine()) != null) {
            sb.append(line);
        }
        return sb.toString();
    }

    @Override
    protected void onPostExecute(String result) {
        if(!isBlank(result)) {
            //String[] arr = result.split("\\|");
            this.textView.setText(result);
        }
    }

    private boolean isBlank(String value){
        return value == null || value.trim().isEmpty();
    }


}

Erstellen des Layouts für die App

Da das Ziel dieser App das Darstellen eines Wertes aus einer Datenbank ist, wird das Layout sehr minimal ausfallen. Jedoch hat die IDE ein komplexes Layout vorbereitet, welches wir wiefolgt überschreiben. (Copy-and-paste)

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_gravity="center_vertical"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:screenOrientation="portrait"
    tools:context=".Hauptfenster" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:text="Large Text"
        android:id="@+id/textView" />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/lesenBtnText"
        android:id="@+id/lesenBtn"
        android:layout_below="@+id/textView"
        android:layout_alignParentStart="true"
        android:layout_marginTop="40dp" />
</RelativeLayout>

Dieses Layout beinhaltet

• ein TextFeld
• eine Schaltfläche

und mehr benötige ich für dieses Tutorial nicht.

Erstellen / Erweitern der Klasse Hauptfenser.java

Auch die Klasse Hauptfenster.java kann wie folgt eingekürzt werden, da der “Rest” für dieses Tutorial unnötig ist.

public class Hauptfenster extends AppCompatActivity {

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

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_hauptfenster, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();
        if (id == R.id.action_settings) { return true;}
        return super.onOptionsItemSelected(item);
    }
}

Erstellen der Aktion für die Schaltfläche “lesenBtn”

Die Schaltfläche soll dazu dienen, dass die lesen Aktion angestoßen wird. Da dieses über einen asyncronen Task geschieht ist mit einer gewissen Verzögerung zu rechnen.
Die Zeit, welche der asyncrone Task benötigt werden, beeinflusst von:

• Geräteleistung,
• Internet geschwindigkeit, Netzwerkverbindung,
• Auslastung des Servers, sowie
• verwendeter Quellcode

Folgender Code wird nun implementiert.

//Textfeld auf dem Layout
final TextView textView = (TextView) findViewById(R.id.textView);

Button lesenBtn = (Button) findViewById(R.id.lesenBtn);
lesenBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
       new ActivityDataSource(textView).execute("someParams");
}
});

Hier ist gut zusehen das wir “nur” der Klasse ActivityDataSource im Konstruktor das TextView Objekt übergeben müssen und den Prozess mit “dataSource.execute();” starten.
Der Methode “execute” können eine beliebige Anzahl (VarArg) von Parametern übergeben werden, welche in der Methode “doInBackground” in der Klasse ActivityDataSource ausgewertet und verwendet werden können.

Die gesamte Klasse “Hauptfenster.java”

package smssca.stefandraegersoftware.de.simplemysqlconnectionapp;

import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.Button;
import android.widget.TextView;

import smssca.stefandraegersoftware.de.simplemysqlconnectionapp.datasource.ActivityDataSource;

public class Hauptfenster extends AppCompatActivity {

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

       final TextView textView = (TextView) findViewById(R.id.textView);

        Button lesenBtn = (Button) findViewById(R.id.lesenBtn);
        lesenBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new ActivityDataSource(textView).execute("someParams");
            }
        });
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_hauptfenster, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();
        if (id == R.id.action_settings) { return true;}
        return super.onOptionsItemSelected(item);
    }
}

Erstellen der PHP Schnittstelle

Als Schnittstelle dient uns eine PHP Datei welche auf einem Server im Internet läuft
(Im idealfall auf demselben Server wie auch die Datenbank.)

Erstellen des Verzeichnisses und ablegen der Datei “reader.php”

Mit der Hilfe eines FTP Programmes wird nun das Verzeichnis auf dem gewünschten Server erstellt und die Datei “reader.php” abgelegt.

PSPAD Editor

Für die weitere Entwicklung in PHP verwende ich den PSPAD Editor welcher kostenlos auf der Herstellerseite http://www.pspad.com/de/ heruntergeladen werden kann.
Der Vorteil dieses Editors ist dass, man Online entwickeln kann, d.h. man baut durch das eingebaute Tool eine FTP Verbindung zum Server auf und kann dort eine Datei bearbeiten und speichern. Die Änderung ist sofort aktiv und müssen nicht erst umständlich hochgeladen werden.

Authentifizierung

Als Sicherheitsmaßnahme habe ich einen authentifizierungsschlüssel implementiert, welcher von der App mit in der URL übergeben wird. Dieser wird in der PHP Datei auf gleichheit geprüft und wenn dieser gleich ist (Case Sensitive) dann geht die Prozedure weiter und wenn nicht, dann wird die gesamte Prozedure abgebrochen und eine Fehlermeldung ausgegeben.

In dieser Methode wird zuerst geprüft, ob die Parameter “authkey” und “method” als POST Parameter vorhanden sind. Wenn diese Vorhanden sind, wird geprüft, ob der Wert für den Parameter “authkey” gleich “meinAuth……” ist. Wenn die Parameter NICHT gesetzt wurden und auch nicht der Key stimmt dann wird jeweils die Fehlermeldung ausgegeben.

function checkAuthCode(){
$fehler0 = "Fehler 0: Keine erfolgreiche Authentifizierung!";
if (isset($_POST['authkey']) AND isset($_POST['method'])){
  $authkey = $_POST['authkey'];
  if ($authkey != 'test321'){
    die($authkey);
  }
} else {
  die(var_dump($_POST));
}
}

Aufbau der Datenbankverbindung

Nachdem die Authentifizierung erfolgreich war, kann nun mit dem Aufbau der Datenbankverbindung begonnen werden.

//Datenbankverbindung aufbauen
$connection = getDBConnection();

function getDBConnection(){
  //Einstellungen der Datenbank
  $dbusername = 'Draeg_gartenroot'; //Benutzername
  $dbpassword = 'g8Uki51!127'; //Passwort
  $dburl='localhost'; //URL
  $dbname='DraegerStefan_gartenmanager'; //Datenbankname


  $fehler1 = "Fehler 1: Fehler beim aufbauen der Datenbankverbindung!";
	$link = mysqli_connect($dburl, $dbusername, $dbpassword,$dbname);
	if (!$link) {
		die('Verbindung schlug fehl: ' . mysqli_error());
	}
  
  /* check connection */
  if (mysqli_connect_errno()) {
       die($fehler1);
  }
  return $link;
}

Für die spätere Verwendung der Datenbankverbindung wird diese in eine Variable gespeichert.

Die Funktion “getDBConnection()” erstellt aus den Werten der Variablen eine Verbindung. Wenn diese nicht erfolgreich ist, wird die Fehlermeldung ausgegeben.

Variablen für die Funktion “getDBConnection()”

Tragen Sie hier die Benutzer und Datenbankeinstellungen ein.
(Es wurden hier die originalen Werte entfernt.)

//Einstellungen der Datenbank
$dbusername = ''; //Benutzername
$dbpassword = ''; //Passwort
$dburl=''; //URL
$dbname=''; //Datenbankname

Lesen der Daten aus der MySQL Datenbank mit PHP

Folgende Funktion liest nun alle Daten aus meiner MySQL Datenbank und gibt diese aus.
Der generierte Output wird mit einem senkrechten Strich getrennt und kann in der Android-App an dieser Stelle geparst werden.

function getAllEntrys($connection){
  $sqlStmt = "SELECT * FROM Plants;";
  $result =  mysqli_query($connection,$sqlStmt);
  $data = array();
  if ($result = $connection->query($sqlStmt)) {
      while ($row = $result->fetch_assoc()) {
        $id = $row["id"];
        $de_name = $row["de_name"];
        array_push($data,array("ID"=> $id,"de_name"=>$de_name));  
      }
  $result->free();
}
  closeConnection($connection);
  
  foreach ($data as $d){
    echo $d["de_name"];
    echo "|";
  }  
}

Die gesamte Datei “reader.php”

<?php


$reportingLevel = -1; //0 für alle PHP Fehler und Warungen ausblenden, -1 für alle anzeigen
error_reporting($reportingLevel); 

//Sicherheitsabfrage ob der Authentifizierungscode mit übergeben wurde.
//Wenn der Code nicht übergeben wurde wird die gesamte Prozedure abgebrochen.
checkAuthCode();

//Datenbankverbindung aufbauen
$connection = getDBConnection();

function getDBConnection(){
  //Einstellungen der Datenbank
  $dbusername = ''; //Benutzername
  $dbpassword = ''; //Passwort
  $dburl=''; //URL
  $dbname=''; //Datenbankname


  $fehler1 = "Fehler 1: Fehler beim aufbauen der Datenbankverbindung!";
	$link = mysqli_connect($dburl, $dbusername, $dbpassword,$dbname);
	if (!$link) {
		die('Verbindung schlug fehl: ' . mysqli_error());
	}
  
  /* check connection */
  if (mysqli_connect_errno()) {
       die($fehler1);
  }
  return $link;
}


$method =  $_POST['method'];

if ($method == 'allEntrys'){
   getAllEntrys($connection);
}

function getAllEntrys($connection){
  $sqlStmt = "SELECT * FROM Plants;";
  $result =  mysqli_query($connection,$sqlStmt);
  $data = array();
  if ($result = $connection->query($sqlStmt)) {
      while ($row = $result->fetch_assoc()) {
        $id = $row["id"];
        $de_name = $row["de_name"];
        array_push($data,array("ID"=> $id,"de_name"=>$de_name));  
      }
  $result->free();
}
  closeConnection($connection);
  
  foreach ($data as $d){
    echo $d["de_name"];
    echo "|";
  }  
}

function checkAuthCode(){
$fehler0 = "Fehler 0: Keine erfolgreiche Authentifizierung!";
if (isset($_POST['authkey']) AND isset($_POST['method'])){
  $authkey = $_POST['authkey'];
  if ($authkey != 'test321'){
    die($authkey);
  }
} else {
  die(var_dump($_POST));
}
}

function closeConnection($connection){
  mysqli_close($connection);
}

?>

Starten der Android Anwendung

Es gibt zwei Möglichkeiten die erstellte Android-App zu starten

• in einem Emulator, oder
• auf einem “echten” Gerät.

Ich starte die Apps immer auf einem “echten” Gerät, da man hier genauso gut debuggen sowie gleich die Oberfläche von der Bedienbarkeit mit der Hand prüfen kann.

Möchte man nun die App Starten so klickt man auf die Schaltfläche .
Nach dem Klick öffnet sich das Fenster für die Auswahl des Gerätes.

Nachdem dieses Fenster mit der Schaltfläche “OK” bestätigt wurde, wird die Anwendung auf das Gerät kopiert, deployt und gestartet. Den gesamten Vorgang kann man in der Konsole verfolgen.

Ändern der SDK Ziel Version

Sollte es hier vorkommen, dass, das Gerät in der List nicht unterstützt wird muss, soweit dieses natürlich der verwendete Quellcode es zulässt die SDK Version geändert werden. Diese Änderung der Version wird in der Datei “build.gradle” durch geführt. (siehe Grafik)

apply plugin: 'com.android.application'

android {
    compileSdkVersion 23
    buildToolsVersion "21.1.2"

    defaultConfig {
        applicationId "smssca.stefandraegersoftware.de.simplemysqlconnectionapp"
        minSdkVersion 17
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.1.1'
    compile 'com.android.support:design:23.1.1'
}

Da ich als Zielgerät ein Samsung Galaxy S2 Plus verwenden muss ich den Wert für “minSdkVersion” von 19 auf 17 ändern. Da die Änderung erst kompiliert und das Projekt erneut gebaut werden muss, “erkennt” dieses die IDE und erzeugt folgende Warnung am oberen Rand der Datei.

Ausgabe auf der Activity in der App

Wenn nun die App gestartet wird, wird folgender Bildschirm angezeigt.

Bei einem “klick” auf die Schaltfläche “Lesen” wird eine Verbindung aufgebaut und die Daten aus der MySQL Datenbank geholt.

Diese Daten können nun ganz einfach geparst werden und in einer Liste oder ähnlichem dargestellt werden.

Das gesamte Android Studio Projekt zum Download