{"id":2963,"date":"2023-11-24T00:11:22","date_gmt":"2023-11-23T23:11:22","guid":{"rendered":"https:\/\/www.art-events.de\/weblog\/?p=2963"},"modified":"2023-11-28T17:38:22","modified_gmt":"2023-11-28T16:38:22","slug":"ae-android-kochbuch-notizen-app-reloaded","status":"publish","type":"post","link":"https:\/\/www.art-events.de\/weblog\/ae-android-kochbuch-notizen-app-reloaded\/","title":{"rendered":"AE Android Kochbuch: Notizen App. Reloaded"},"content":{"rendered":"

Unser AE Android Kochbuch Teil 3A: Notizen App Reloaded. Schreiben. Speichern. Laden. Vorlesen lassen.<\/p>\n

In Teil 3 pr\u00e4sentierte ich eine kleine Notizbuch App, die aber nur eingeschr\u00e4nkt nutzbar war. Daher gibt es hier Teil 3A – die Notizen App Reloaded! In diesem Teil widme ich mich dem gleichen Thema, aber nun basteln wir die App so, dass man sie auch sinnvoll verwenden kann. Und wer es eilig hat: die App bekommt auch eine Funktion, dass sie euch eure Notizen vorlesen kann!<\/p>\n

\"\"<\/a><\/p>\n

Unser AE Android Kochbuch f\u00fcr Praktiker. Hier zeige ich euch wie ihr schnell und einfach Android programmieren lernt. Tipps aus der Praxis. Vorweg noch mal der Hinweis: Dieses ist zwar ein Grundkurs, aber ihr solltet schon etwas Grundlagenwissen haben. Zum Beispiel wissen, was eine Variable ist, und dass man Zahlen in Integer und Texte in String Variablen speichert. Wenn euch solche Basics noch fremd sind \u2013 ich empfehle die ersten Kapitel vom Buch Java ist auch nur eine Insel oder andere Literatur, die euch in solche grundlegenden Dinge einf\u00fchrt.<\/p>\n

Die Ausgangslage<\/h3>\n

Android Studio aktiv. Ich benutze jetzt die gerade aktuelle Version Giraffe. Neues Java Projekt Writer ist angelegt.<\/p>\n

<\/a>Layout Datei<\/h3>\n

Wie auch schon in den Teilen davor beginnen wir mit der Layout Gestaltung.<\/p>\n

<\/a>Eingabefenster<\/h4>\n

Prim\u00e4r verwenden wir ein Element EditText, das wir auf Multiline setzen, damit wir mehrere Zeilen eingeben k\u00f6nnen. Nat\u00fcrlich vergeben wir auch eine id, damit wir den Inhalt von EditText vom Java Programm aus lesen oder ver\u00e4ndern k\u00f6nnen.<\/p>\n

<EditText \r\nandroid:id=\"@+id\/editTextText\" \r\nandroid:layout_width=\"match_parent\" \r\nandroid:layout_height=\"300dp\" \r\nandroid:background=\"@drawable\/drawback\" \r\nandroid:gravity=\"top\" \r\nandroid:scrollHorizontally=\"false\" \r\nandroid:scrollbars=\"vertical\" \r\nandroid:inputType=\"textMultiLine\" \r\nandroid:text=\"\" \/><\/pre>\n
<\/a>Buttons f\u00fcr Benutzeraktivit\u00e4ten<\/h4>\n
Dem Benutzer spendieren wir sinnvollerweise die Buttons:<\/p>\n
-) Button Notizen laden<\/strong><\/p>\n
Der Benutzer soll aus gespeicherten Notizen ausw\u00e4hlen und diese laden.<\/p>\n
-) Button Notizen speichern<\/strong><\/p>\n
Notizen k\u00f6nnen als Datei gespeichert werden.<\/p>\n
-) Button Notiz vorlesen<\/strong><\/p>\n
Die App soll eine Notiz vorlesen.<\/p>\n
-) Notiz Fenster l\u00f6schen<\/strong><\/p>\n
Der Inhalt im Notiz Fenster soll komplett entfernt werden.<\/p>\n
Die ersten drei Buttons basteln wir in der Layout Datei in gewohnter Form direkt unterhalb dem Eingabefenster. Das Ganze kapseln wir in einem horizontalem Layout, damit die Buttons nebeneinander stehen.<\/p>\n
<LinearLayout \r\nandroid:layout_width=\"match_parent\" \r\nandroid:layout_height=\"wrap_content\" \r\nandroid:orientation=\"horizontal\"> \r\n\r\n<Button \r\nandroid:id=\"@+id\/buttonLaden\" \r\nandroid:layout_width=\"120dp\" \r\nandroid:layout_height=\"wrap_content\" \r\nandroid:text=\"Laden\" \/> \r\n\r\n<Button \r\nandroid:id=\"@+id\/buttonSpeichern\" \r\nandroid:layout_width=\"120dp\" \r\nandroid:layout_height=\"wrap_content\" \r\nandroid:layout_marginLeft=\"10dp\" \r\nandroid:text=\"Speichern\" \/> \r\n\r\n<Button \r\nandroid:id=\"@+id\/buttonVorlesen\" \r\nandroid:layout_width=\"120dp\" \r\nandroid:layout_height=\"wrap_content\" \r\nandroid:layout_marginLeft=\"10dp\" \r\nandroid:text=\"Vorlesen\" \/> \r\n<\/LinearLayout><\/pre>\n
<\/a>Der Imagebutton zum L\u00f6schen<\/h4>\n
Zum L\u00f6schen des Eingabefensters verwenden wir das Element ImageButton, weil ein kleines Piktogramm ausreichen sollte, um die Funktion des Buttons klar zu machen.<\/p>\n
Den Imagebutton zieht ihr in der Design Ansicht aus der Palette Buttons einfach wie gewohnt in eure Layout Ansicht.<\/p>\n
<\/p>\n
Damit der Button ein Bild bekommt: Das Bild f\u00fcr den Imagebutton w\u00e4hlen wir in Ressource. In meinem Fall soll das einfach nur das \u00fcbliche X sein.<\/p>\n
Um das Bild f\u00fcr den Imagebutton zu w\u00e4hlen: einfach den Cursor im Projektfenster auf RES platzieren und mit der rechten Maustaste bekommt ihr ein Auswahlmen\u00fc NEW um dann ein Bild als Vector Asset auszuw\u00e4hlen.<\/p>\n
<\/p>\n
Klickt dann in der Maske einfach in das Feld Clip Art und ihr erhalten eine \u00dcbersicht \u00fcber die verf\u00fcgbaren Clip Arts aus denen ihr dann ausw\u00e4hlen k\u00f6nnt. Ihr k\u00f6nnt nun durch die Cllip Arts scrollen oder im Suchfeld Clear angeben. Je naachdem, wie ihr vorgehen woll. Am Ende sollte es dann mal so aussehen und ihr k\u00f6nnt das Bild als Ressource \u00fcbernehmen.<\/p>\n
<\/p>\n
Last not least die Ressource in der XML Datei beim Image Button einbauen:<\/p>\n
<ImageButton \r\nandroid:id=\"@+id\/imageButton_clrText\" \r\nandroid:layout_width=\"40dp\" \r\nandroid:layout_height=\"40dp\" \r\napp:srcCompat=\"@drawable\/baseline_clear_24\" \/><\/pre>\n
<\/a>Layout komplett<\/h4>\n
Somit erhalten wir die Layout Datei:<\/p>\n
<?<\/em>xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<\/em> <LinearLayout xmlns:android=\"http:\/\/schemas.android.com\/apk\/res\/android\" \r\nxmlns:app=\"http:\/\/schemas.android.com\/apk\/res-auto\" \r\nxmlns:tools=\"http:\/\/schemas.android.com\/tools\" \r\nandroid:layout_width=\"match_parent\" \r\nandroid:layout_height=\"match_parent\" \r\nandroid:orientation=\"vertical\" \r\ntools:context=\".MainActivity\"> \r\n\r\n<TextView \r\nandroid:layout_width=\"wrap_content\" \r\nandroid:layout_height=\"wrap_content\" \r\nandroid:text=\"Willkommen im AE Mini Writer\" \/> \r\n\r\n<ImageButton \r\nandroid:id=\"@+id\/imageButton_clrText\" \r\nandroid:layout_width=\"40dp\" \r\nandroid:layout_height=\"40dp\" \r\napp:srcCompat=\"@drawable\/baseline_clear_24\" \/> \r\n\r\n<EditText \r\nandroid:id=\"@+id\/editTextText\" \r\nandroid:layout_width=\"match_parent\" \r\nandroid:layout_height=\"300dp\" \r\nandroid:background=\"@drawable\/drawback\" \r\nandroid:gravity=\"top\" \r\nandroid:scrollHorizontally=\"false\" \r\nandroid:scrollbars=\"vertical\" \r\nandroid:inputType=\"textMultiLine\" \r\nandroid:text=\"\" \/> \r\n\r\n<LinearLayout \r\nandroid:layout_width=\"match_parent\" \r\nandroid:layout_height=\"wrap_content\" \r\nandroid:orientation=\"horizontal\"> \r\n\r\n<Button \r\nandroid:id=\"@+id\/buttonLaden\" \r\nandroid:layout_width=\"120dp\" \r\nandroid:layout_height=\"wrap_content\" \r\nandroid:text=\"Laden\" \/> \r\n\r\n<Button \r\nandroid:id=\"@+id\/buttonSpeichern\" \r\nandroid:layout_width=\"120dp\" \r\nandroid:layout_height=\"wrap_content\" \r\nandroid:layout_marginLeft=\"10dp\" \r\nandroid:text=\"Speichern\" \/> \r\n\r\n<Button \r\nandroid:id=\"@+id\/buttonVorlesen\" \r\nandroid:layout_width=\"120dp\" \r\nandroid:layout_height=\"wrap_content\" \r\nandroid:layout_marginLeft=\"10dp\" \r\nandroid:text=\"Vorlesen\" \/> \r\n\r\n<\/LinearLayout> \r\n\r\n<\/LinearLayout><\/pre>\n
<\/a>Der Java Code<\/h3>\n
Wechseln wir jetzt in die Datei MainAcitivity.java und f\u00fcllen die App mit Leben.<\/p>\n
private static EditText etEingabe1<\/em>;<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> @Override \r\nprotected void onCreate(Bundle savedInstanceState) { \r\n  super.onCreate(savedInstanceState); \r\n  setContentView(R.layout.activity_main<\/em>); \r\n\r\n  \/\/EditText Variable init - weil wir sie ueberall nutzen\r\n  etEingabe1 <\/em>= findViewById(R.id.editTextText<\/em>); \r\n\r\n  \/\/Listener fuer Buttons registrieren\r\n<\/em>  findViewById(R.id.imageButton_clrText<\/em>).setOnClickListener(this); \r\n  findViewById(R.id.buttonLaden<\/em>).setOnClickListener(this); \r\n  findViewById(R.id.buttonSpeichern<\/em>).setOnClickListener(this); \r\n  findViewById(R.id.buttonVorlesen<\/em>).setOnClickListener(this); \r\n\r\n  \/\/am Start: Cursor in das Textfeld setzen\r\n  etEingabe1<\/em>.requestFocus(); \r\n}<\/pre>\n
Das Eingabefenster als editText Element wird der EditText Variable etEingabe1 zugewiesen. Die Variable wird au\u00dferhalb der Methode deklariert, damit wir sie in der ganzen Klasse nutzen k\u00f6nnen, ohne sie jedes Mal neu zuweisen zu m\u00fcssen. Die Zuweisung hingegen findet in der Methode onCreate statt. Last not least stellen wir den Cursor ins Eingabefenster, damit der Benutzer gleich tippen kann.<\/p>\n
In der Methode onCreate registrieren wir die vier Buttons jeweils mit einem onClickListener. Ob ImageButton oder normaler Button spielt dabei keine Rolle. Alle Button Elemente werden identisch registriert. Wir erhalten dann den onClick Listener, bei dem wir die Aktionen f\u00fcr jeden Button eintragen.<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> @Override \r\npublic void onClick(View v) { \r\n  \/\/Unser Eingabe Listener\r\n<\/em> <\/i> switch (v.getId()) {\r\n    \/\/hier tragen wir die Aktionen f\u00fcr die Buttons ein\r\n }\r\n}<\/pre>\n
<\/a>Image Button L\u00f6schen<\/h4>\n
Mit dem kleinen Imagebutton kann ich das Eingabefenster jederzeit l\u00f6schen. Grafik und Design des Buttons finden sich in der XML Layout Datei. Im Java Code lege ich die Aktionen fest, wenn der Button geklickt wird. Konkret geschieht das in der switch Schleife in der onClick Methode. Dort hinterlege ich die Aktionen, was passiert, wenn der Benutzer den Image Button bet\u00e4tigt.<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> @Override \r\npublic void onClick(View v) { \r\n  \/\/Unser Eingabe Listener\r\n<\/em>  switch (v.getId()) { \r\n    case R.id.imageButton_clrText<\/em>: \r\n    \/\/Button CLEAR\r\n    etEingabe1<\/em>.setText(\"\"); \r\n    etEingabe1<\/em>.requestFocus(); \r\n    break;\r\n  }\r\n}<\/pre>\n
<\/a>Daten speichern und laden von \u00f6ffentlichen Orten. Intents<\/h4>\n
Bevor wir uns jetzt mit dem Buttons Speichern und Laden besch\u00e4ftigen, m\u00fcssen wir \u00fcber Intents reden. Intents sind die Google Antwort, damit wir per Software auf alle m\u00f6glichen Ressourcen des Smartphone zugreifen und trotzdem die von Google erw\u00fcnschten Sicherheitsstandards einhalten. Hierbei gilt: Eine Anwendung darf nicht ohne Erlaubnis auf Ressourcen des Smartphone zugreifen, sondern ben\u00f6tigt immer eine Erlaubnis oder Aktion des Benutzers.<\/p>\n
In unserem Fall werden wir Intents verwenden, um Daten zu speichern und Daten zu lesen. Dateiname der Datei sowie Speicherort kann der Benutzer jeweils individuell vergeben. Wegen der unterschiedlichen Rechte auf verschiedenen Verzeichnissen empfehle ich, das \/Downloads Verzeichnis zu verwenden. Wer mag, kann sich hier ein weiteres Unterverzeichnis anlegen.<\/p>\n
In Intent besteht aus Sicht des Programms immer aus folgenden Aktionen:<\/p>\n
1) Request Code f\u00fcr verschiedene Intents definieren<\/p>\n
2) Ein Intent wird aufgerufen<\/p>\n
3) Ein Intent wurde aktiviert und muss ausgewertet werden<\/p>\n
Request Code f\u00fcr Intent definierern<\/strong><\/p>\n
Damit verschiedene Intents voneinander trennen k\u00f6nnen, bekommen sie beim Aufruf einen beliebigen Request Code mitgeteilt, den ihr dann sp\u00e4ter in der Auswertung abfragen k\u00f6nnt. Zu diesem Zweck vergebe ich am Anfang der Klasse f\u00fcr verschiedene Intents unterschiedliche Id Werte, z.B:<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> public class MainActivity extends AppCompatActivity implements View.OnClickListener { \r\n\r\nprivate static final int REQUESTCODE_SAVE <\/em>= 123; \/\/Requestcode f. Export \/ Save\r\n<\/em>private static final int REQUESTCODE_LOAD <\/em>= 125; \/\/Requestcode f. Import \/ Laden\r\n<\/em>private static final int REQUESTCODE_CAMERA <\/em>= 160; \/\/Requestcode f. Camera \/ Scanner<\/em><\/pre>\n
Die ID Werte sind rein willk\u00fcrlich gew\u00e4hlt. Wichtig ist nur, dass ihr sie unterscheiden k\u00f6nnen. Also wenn Save und Camera den gleichen Wert aufweisen, wird es ein Problem geben.<\/p>\n
Intent aufrufen<\/strong><\/p>\n
Den Aufruf eines Intentes k\u00f6nnen ihr in eurem Java Code dort unterbringen, wo ihr es gerne habt. Also z.b. in der onClick Methode, wenn ein Button bet\u00e4tigt wird. Abh\u00e4ngig von dem, was der Benutzer machen soll, bekommen die Intents unterschiedliche Start Werte. Nachstehendes Beispiel zeigt wie man das Intent zum Anlegen und Speichern einer reinen Text Datei aufruft:<\/p>\n
Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT<\/em>); \r\nintent.addCategory(Intent.CATEGORY_DEFAULT<\/em>); \r\nintent.setType(\"text\/plain\"); \r\nintent.putExtra(Intent.EXTRA_TITLE<\/em>, \"\"); \r\nstartActivityForResult(intent, REQUESTCODE_SAVE<\/em>);<\/pre>\n
Es versteht sich vermutlich, dass das Intent f\u00fcr die eingebaute Camera etwas anders aussehen wird. Ihr m\u00fcsst euch also jedes Mal \u00fcber das Intent informieren, wenn ihr eins verwenden wollt.<\/p>\n
Intent auswerten<\/strong><\/p>\n
Das Abfragen von Intents geschieht hingegen in der Methode onAcitivityResult. Diese Methode ist f\u00fcr alle Intents da, d.h. ihr m\u00fcsst selbst abfragen, welches Intent gerade durchgef\u00fchrt wurde. Ob z.B. der Benutzer die Camera verwendet hat, um Barcode zu lesen oder ob eine Datei gespeichert werden soll. Beispiel f\u00fcr die Methode, wobei ich bereits auf die Intents Datei speichern und Datei laden abfrage:<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> public void onActivityResult(int requestCode, int resultCode, Intent resultData) { \r\n  \/\/Intent auswerten\r\n\r\n<\/em>  super.onActivityResult(requestCode, resultCode, resultData); \r\n\r\n  \/\/Intent: Datei speichern\r\n<\/em>  if (requestCode == REQUESTCODE_SAVE <\/em>&& resultCode == Activity.RESULT_OK<\/em>) { \r\n    \/\/hier kommt der Code zum Speichern rein<\/em> \r\n  } \r\n\r\n  \/\/Intent: Datei laden\r\n<\/em>  if (requestCode == REQUESTCODE_LOAD <\/em>&& resultCode == Activity.RESULT_OK<\/em>) {\r\n    \/\/hier kommt der Code zum Laden rein<\/em> \r\n  } \r\n}<\/pre>\n
<\/a>Button Notiz speichern<\/h4>\n
Genauso wie oben geht es auch mit dem Button Notiz. Hier soll eine Speicherroutine aktiviert werden, bei der Benutzer Dateinamen und Speicherort ausw\u00e4hlen kann, wenn er seine Notiz speichert. Die Aktionen f\u00fcr den Button werden daher auch hier wieder in der switch Schleife in der Methode onClick eingetragen. Da ich \u00fcber Intents speichern will \u2013 wie oben angef\u00fchrt:<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> @Override \r\npublic void onClick(View v) { \r\n  \/\/Unser Eingabe Listener\r\n\r\n<\/em>  Intent intent = new Intent(); \r\n\r\n  switch (v.getId()) { \r\n... \r\n\r\n    case R.id.buttonSpeichern<\/em>: \r\n      intent = new Intent(Intent.ACTION_CREATE_DOCUMENT<\/em>); \r\n      intent.addCategory(Intent.CATEGORY_DEFAULT<\/em>); \r\n      intent.setType(\"text\/plain\"); \r\n      intent.putExtra(Intent.EXTRA_TITLE<\/em>, \"\"); \r\n      startActivityForResult(intent, REQUESTCODE_SAVE<\/em>); \r\n      break;\r\n\r\n  }\r\n}<\/pre>\n
Zum Abfragen des Intents nutzen wir unsere onActivityResult Methode.<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> public void onActivityResult(int requestCode, int resultCode, Intent resultData) { \r\n  \/\/Intent auswerten\r\n\r\n<\/em>  super.onActivityResult(requestCode, resultCode, resultData); \r\n\r\n  \/\/Intent: Datei speichern\r\n<\/em>  if (requestCode == REQUESTCODE_SAVE <\/em>&& resultCode == Activity.RESULT_OK<\/em>) { \r\n    Uri uri = null; \r\n    if (resultData != null) { \r\n      uri = resultData.getData(); \r\n      doSaveData2Uri (etEingabe1<\/em>, uri); \r\n    } \r\n  } \r\n}<\/pre>\n
Intents mit Datei Operationen liefern uns eine Uri. Eine URI ist im Prinzip auch ein Verweis auf eine Datei, aber etwas spezieller als nur Datenpfad und Dateiname. Info zur URI hier<\/a>! F\u00fcr mich bedeutet dass, ich muss eine Speichermethode doSaveData2Uri so bauen, dass ich \u00fcber eine URI speichern kann. Als Parameter gebe ich der Methode das Element EditText und und die Uri mit, wo die Dateien hin sollen.<\/p>\n
Fehlt nur noch die Methode zum Speichern einer Datei, die \u00fcber eine URI definiert wird.<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> private void doSaveData2Uri (EditText etQuelle, Uri uri) { \r\n  \/\/Save Date von EditText in Datei via URI\r\n\r\n<\/em>  String myData = etQuelle.getText().toString(); \r\n\r\n  try { \r\n    OutputStream stream = getContentResolver().openOutputStream(uri, \"wt\"); \r\n    PrintWriter writer = new PrintWriter(stream); \r\n    writer.write(myData); \r\n    writer.flush(); \r\n    stream.close(); \r\n    Toast.makeText<\/em>(this, \"Datei wurde gespeichert!\", Toast.LENGTH_LONG<\/em>).show(); \r\n  } catch (Exception e) { \r\n    Log.e<\/em>(getLocalClassName(), \"caught IOException\", e); \r\n    Log.d <\/em>(\"ERROR\", e.toString()); \r\n  } \r\n}<\/pre>\n
F\u00fcr das Speichern definiere ich mir mittels getCotentResolver einen Output Stream mit der angegebenen Uri und dem Paramter \u201ewt\u201c. Das wt ist wichtig. W\u00fcrde ich den Paramter weglassen, werden neue Daten zwar in die Datei gespeichert, wenn die Datei aber vorher l\u00e4nger war, bleibt der alte Dateninhalt noch erhalten. Mittels t wird ein truncate erzwungen, d.h. die Datei wird nach dem Speichern der Informationen abgeschnitten, so dass keine alten Daten mehr enthalten sind.<\/p>\n
Der eigentliche Speichervorgang findet dann mit writer.write statt. Hier wird der Inhalt des Elements EditText einfach als Stringwert gespeichert und die Datei geschlossen. Am Schluss gebe ich mir mittels Toast Message noch eine kleine Meldung aus, dass der Speichervorgang vollzogen wurde.<\/p>\n
<\/a>Button Notiz laden<\/h4>\n
Der Lade Button l\u00e4uft fast \u00e4hnlich wie der Speicher Button \u2013 nur anders herum! Wieder wird der switch in der onClick Methode erweitert. Dieses Mal rufe ich ein Intent zum \u00d6ffnen und Lesen einer TEXT Datei auf und verwenden den Requestcode LOAD.<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> @Override \r\npublic void onClick(View v) { \r\n  \/\/Unser Eingabe Listener\r\n\r\n<\/em>  Intent intent = new Intent(); \r\n\r\n  switch (v.getId()) { \r\n  ... \r\n    case R.id.buttonLaden<\/em>: \r\n      intent = new Intent (Intent.ACTION_OPEN_DOCUMENT<\/em>); \r\n      intent.addCategory(Intent.CATEGORY_DEFAULT<\/em>); \r\n      intent.setType(\"text\/plain\"); \r\n      intent.putExtra(Intent.EXTRA_TITLE<\/em>, \"\"); \r\n      startActivityForResult(intent, REQUESTCODE_LOAD<\/em>); \r\n      break; \r\n  } \r\n}<\/pre>\n
Analog dazu in der Methode onActivityResult die Abfrage ob das Intent zum \u00d6ffnen und Lader einer Text Datei ausgew\u00e4hlt wurde und ich bastele mir eine Methode, bei der eine Datei unter Angabe einer URI geladen wird:<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> public void onActivityResult(int requestCode, int resultCode, Intent resultData) { \r\n  \/\/Intent auswerten\r\n<\/em> ... \r\n  \/\/Intent: Datei laden\r\n<\/em>  if (requestCode == REQUESTCODE_LOAD <\/em>&& resultCode == Activity.RESULT_OK<\/em>) { \r\n    Uri uri = null; \r\n    if (resultData != null) { \r\n      uri = resultData.getData(); \r\n      doLoadDataFromUri (uri, etEingabe1<\/em>); \r\n    } \r\n  } \r\n}<\/pre>\n
Auch hier nehme ich wieder eine eigene Methode, die ich doLoadDataFromUri nenne. Als Parameter gebe ich die die vom Benutzer ausgew\u00e4hlte Uri und das EditText Elemtn mit, in dem die Daten angezeigt werden sollen. Die Lademethode dann im Detail:<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> private void doLoadDataFromUri (Uri myUri, EditText etZiel) { \r\n\/\/Text Datei laden von URI. Dann in EditText anzeigen\r\n\r\n<\/em>try { \r\n  InputStreamReader inputStreamReader = new InputStreamReader(getContentResolver().openInputStream(myUri)); \r\n  BufferedReader bufferedReader = new BufferedReader(inputStreamReader); \r\n  StringBuilder sb = new StringBuilder(); \r\n  String s = \"\"; \r\n\r\n  \/\/Datei lesen, String aufbauen\r\n<\/em>  while ((s = bufferedReader.readLine()) != null) { \r\n    Log.d <\/em>(\"Akt gelesen\", s); \r\n    sb.append(s); \r\n  } \r\n\r\n  \/\/Wenn fertig mit lesen: String nach EditText anzeigen\r\n<\/em>  String fileContent = sb.toString(); \r\n  bufferedReader.close(); \r\n  etZiel.setText(fileContent); \r\n\r\n  } catch (IOException e) { \r\n    \/\/Fehlerbehandlung bei Ausnahme\r\n<\/em>    Log.e<\/em>(getLocalClassName(), \"caught IOException\", e); \r\n  } \r\n}<\/pre>\n
Dieses Mal hole ich mir einen Stream Reader mit dem ich die Daten lese, mir mittels String Builder einen gro\u00dfen String aufbauen und diesen am Schluss in die als Parameter \u00fcbergebene EditText anzeige.<\/p>\n
<\/a>Button Vorlesen<\/h4>\n
Das machen wir uns einfach und verwenden die Text To Speach Routinen, die uns Google anbietet. Eine private Variable TextToSpeech deklairieren und in der onInit Funktion auf das Textfenster setzen. Dazu kann ich noch den Dialekt spezfizieren \u2013 ich h\u00e4tte es gerne halbwegs verst\u00e4ndlich \u2013 also Deutsch \/ Deutsch! Im onClick Listener aktivere ich dann die Vorlesefunktion und fertig. Sieht dann konkret so aus:<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> public class MainActivity extends AppCompatActivity implements View.OnClickListener, TextToSpeech.OnInitListener { \r\n\r\n...\r\n\r\nprivate TextToSpeech tts;\r\n\r\n\u2026.\r\n\r\n\/\/----------------------------------------------------------------------\r\n<\/em> @Override \r\npublic void onClick(View v) { \r\n  \/\/Unser Eingabe Listener\r\n\u2026.<\/em> \r\n  switch (v.getId()) { \r\n\u2026. \r\n    case R.id.buttonVorlesen<\/em>: \r\n      tts = new TextToSpeech(this, this); \r\n      tts.shutdown(); \r\n      break; \r\n  } \r\n}\r\n\r\n\u2026.\r\n\r\n\/\/----------------------------------------------------------------------\r\n<\/em> @Override \r\npublic void onInit(int i) { \r\n  String S1 = etEingabe1<\/em>.getText().toString(); \r\n  tts.setLanguage(Locale.GERMAN<\/em>); \r\n  tts.speak(S1, TextToSpeech.QUEUE_FLUSH<\/em>, null); \r\n}<\/pre>\n
Das war es schon.<\/p>\n
<\/a>Java Code komplett<\/h4>\n
Hinweis: Leider ist die Formatierung etwas besch\u00e4digt. Die Klammern und Einr\u00fcckungen sind umgefallen!<\/p>\n
\/\/----------------------------------------------------------------------\r\n<\/em> public class MainActivity extends AppCompatActivity implements View.OnClickListener, TextToSpeech.OnInitListener { \r\n\r\nprivate static EditText etEingabe1<\/em>; \r\n\r\nprivate static final int REQUESTCODE_SAVE <\/em>= 123; \/\/Requestcode f. Export \/ Save\r\n<\/em>private static final int REQUESTCODE_LOAD <\/em>= 125; \/\/Requestcode f. Import \/ Laden\r\n<\/em>private static final int REQUESTCODE_CAMERA <\/em>= 160; \/\/Requestcode f. Camera \/ Scanner\r\n\r\n<\/em>private TextToSpeech tts; \r\n\r\n\/\/----------------------------------------------------------------------\r\n<\/em>@Override \r\nprotected void onCreate(Bundle savedInstanceState) { \r\n  super.onCreate(savedInstanceState); \r\n  setContentView(R.layout.activity_main<\/em>); \r\n\r\n  \/\/EditText Variable init - weil wir sie ueberall nutzen\r\n  etEingabe1 <\/em>= findViewById(R.id.editTextText<\/em>); \r\n\r\n  \/\/Listener fuer Buttons registrieren\r\n<\/em>  findViewById(R.id.imageButton_clrText<\/em>).setOnClickListener(this); \r\n  findViewById(R.id.buttonLaden<\/em>).setOnClickListener(this); \r\n  findViewById(R.id.buttonSpeichern<\/em>).setOnClickListener(this); \r\n  findViewById(R.id.buttonVorlesen<\/em>).setOnClickListener(this); \r\n\r\n  \/\/am Start: Cursor in das Textfeld setzen\r\n  etEingabe1<\/em>.requestFocus(); \r\n} \r\n\r\n\/\/----------------------------------------------------------------------\r\n<\/em>@Override \r\npublic void onClick(View v) { \r\n  \/\/Unser Eingabe Listener\r\n\r\n<\/em>  Intent intent = new Intent(); \r\n\r\n  switch (v.getId()) { \r\n    case R.id.imageButton_clrText<\/em>: \r\n      \/\/Button CLEAR\r\n      etEingabe1<\/em>.setText(\"\"); \r\n      etEingabe1<\/em>.requestFocus(); \r\n      break; \r\n\r\n    case R.id.buttonSpeichern<\/em>: \r\n      intent = new Intent(Intent.ACTION_CREATE_DOCUMENT<\/em>); \r\n      intent.addCategory(Intent.CATEGORY_DEFAULT<\/em>); \r\n      intent.setType(\"text\/plain\"); \r\n      intent.putExtra(Intent.EXTRA_TITLE<\/em>, \"\"); \r\n      startActivityForResult(intent, REQUESTCODE_SAVE<\/em>); \r\n      break; \r\n\r\n    case R.id.buttonLaden<\/em>: \r\n      intent = new Intent (Intent.ACTION_OPEN_DOCUMENT<\/em>); \r\n      intent.addCategory(Intent.CATEGORY_DEFAULT<\/em>); \r\n      intent.setType(\"text\/plain\"); \r\n      intent.putExtra(Intent.EXTRA_TITLE<\/em>, \"\"); \r\n      startActivityForResult(intent, REQUESTCODE_LOAD<\/em>); \r\n      break; \r\n\r\n    case R.id.buttonVorlesen<\/em>: \r\n      tts = new TextToSpeech(this, this); \r\n      tts.shutdown(); \r\n      break; \r\n  } \r\n} \r\n\r\n\/\/----------------------------------------------------------------------\r\n<\/em>@Override \r\npublic void onInit(int i) { \r\n  String S1 = etEingabe1<\/em>.getText().toString(); \r\n  tts.setLanguage(Locale.GERMAN<\/em>); \r\n  tts.speak(S1, TextToSpeech.QUEUE_FLUSH<\/em>, null); \r\n} \r\n\r\n\/\/----------------------------------------------------------------------\r\n<\/em>public void onActivityResult(int requestCode, int resultCode, Intent resultData) { \r\n  \/\/Intent auswerten\r\n\r\n<\/em>  super.onActivityResult(requestCode, resultCode, resultData); \r\n\r\n  \/\/Intent: Datei speichern\r\n<\/em>  if (requestCode == REQUESTCODE_SAVE <\/em>&& resultCode == Activity.RESULT_OK<\/em>) { \r\n    Uri uri = null; \r\n    if (resultData != null) { \r\n      uri = resultData.getData(); \r\n      doSaveData2Uri (etEingabe1<\/em>, uri); \r\n    } \r\n  } \r\n\r\n  \/\/Intent: Datei laden\r\n<\/em>  if (requestCode == REQUESTCODE_LOAD <\/em>&& resultCode == Activity.RESULT_OK<\/em>) { \r\n    Uri uri = null; \r\n    if (resultData != null) { \r\n      uri = resultData.getData(); \r\n      doLoadDataFromUri (uri, etEingabe1<\/em>); \r\n    } \r\n  } \r\n\r\n  \/\/Andere RequestCodes hier einbauen\r\n<\/em>} \r\n\r\n\/\/----------------------------------------------------------------------\r\n<\/em>private void doSaveData2Uri (EditText etQuelle, Uri uri) { \r\n  \/\/Save Date von EditText in Datei via URI\r\n\r\n<\/em>  String myData = etQuelle.getText().toString(); \r\n\r\n  try { \r\n    OutputStream stream = getContentResolver().openOutputStream(uri, \"wt\"); \r\n    PrintWriter writer = new PrintWriter(stream); \r\n    writer.write(myData); \r\n    writer.flush(); \r\n    stream.close(); \r\n    Toast.makeText<\/em>(this, \"Datei wurde gespeichert!\", Toast.LENGTH_LONG<\/em>).show();\r\n  } catch (Exception e) { \r\n    Log.e<\/em>(getLocalClassName(), \"caught IOException\", e); \r\n    Log.d <\/em>(\"ERROR\", e.toString()); \r\n  } \r\n} \r\n\r\n\/\/----------------------------------------------------------------------\r\n<\/em>private void doLoadDataFromUri (Uri myUri, EditText etZiel) { \r\n  \/\/Text Datei laden von URI. Dann in EditText anzeigen\r\n\r\n<\/em>  try { \r\n    InputStreamReader inputStreamReader = new InputStreamReader(getContentResolver().openInputStream(myUri)); \r\n    BufferedReader bufferedReader = new BufferedReader(inputStreamReader); \r\n    StringBuilder sb = new StringBuilder(); \r\n    String s = \"\"; \r\n\r\n    \/\/Datei lesen, String aufbauen\r\n<\/em>    while ((s = bufferedReader.readLine()) != null) { \r\n      Log.d <\/em>(\"Akt gelesen\", s); \r\n      sb.append(s); \r\n    } \r\n\r\n    \/\/Wenn fertig mit lesen: String nach EditText anzeigen\r\n<\/em>    String fileContent = sb.toString(); \r\n    bufferedReader.close(); \r\n    etZiel.setText(fileContent); \r\n\r\n  } catch (IOException e) { \r\n    \/\/Fehlerbehandlung bei Ausnahme\r\n<\/em>    Log.e<\/em>(getLocalClassName(), \"caught IOException\", e); \r\n  } \r\n} \r\n\r\n} \/\/end class<\/em><\/pre>\n
<\/a>Der Testlauf<\/h3>\n
In den vorherigen Teilen habe ich es ausf\u00fchrlich behandelt. Um die App nun im Emulator zu starten: Device Emulator mit einem ausgew\u00e4hlten Ger\u00e4t starten, App starten. Das Ergebnis sieht dann erwartungsgem\u00e4\u00df so aus:<\/p>\n
<\/p>\n
Spielen wir mit allen Funktionen herum, um uns einen Eindruck von der kleinen App zu verschaffen. Wir k\u00f6nnen Texte tippen, speichern, laden und vorlese lassen. Tipp: wenn ihr beim Vorlesen nichts h\u00f6rt \u2013 Lautst\u00e4rke im Device Emulator hochdrehen. Gibt extra Buttons f\u00fcr die Lautst\u00e4rke auf dem Smartphone!<\/p>\n
<\/a>Fehlersuche \/ Optimierung<\/h3>\n
Programmierung ist Handwerk. Viele verschiedene Wege f\u00fchren zum Ergebnis und manchmal geschehen unerwartete Sachen. Daher m\u00fcssen wir Programmierer unser Werk testen. M\u00f6glichst bevor Kunden oder echte Einsatzf\u00e4lle es tun.<\/p>\n
Code abzutippen ist heute einfach geworden. Einfach aus dem Internet ein paar Codeschnipsel kopieren, fertig ist ein Programm. Doch wie gut ein Programm ist, entscheidet der Alltag. Ich verbringe z.B. genauso viel Zeit mit dem Testen der Software wie mit dem Programmieren. Und trotzdem passieren im Alltag Sachen mit denen ich nicht rechnete.<\/p>\n
Im Fall unserer Anwendung stellt man recht schnell fest, dass etwas nur suboptimal l\u00e4uft. Wird Beispielsweise der Text unten gespeichert und anschlie\u00dfend wieder geladen, sieht er ver\u00e4ndert aus.<\/p>\n
<\/p>\n
Wenn ich das jetzt speichere und mir im Device Explorer die Datei ansehe sieht sie so aus:<\/p>\n
<\/p>\n
Wenn ich die Datei aber dann wieder lade schaut sie so aus.<\/p>\n
<\/p>\n
Offensichtlich hat sie ihre Zeilenumbr\u00fcche verloren und alles wird einfach hintereinander angezeigt. Um zu begreifen, was passiert ist, mache ich folgendes:<\/p>\n
Ich gebe den Text neu ein und starte den Device Explorer. Dort navigiere ich in das Verzeichnis \/Download und \u00fcbertragen die Datei an meinen PC. Auf dem PC schaue ich sie mir in einem Editor in verschiedenen Darstellungen, zuerst in der ASCII Text und anschlie\u00dfend in der HEX Darstellung.<\/p>\n
<\/p>\n
Anschlie\u00dfend wiederhole ich den Vorgang mit der Datei, die nach dem Laden keine Zeilenumbr\u00fcche mehr hat.<\/p>\n
<\/p>\n
Beim Vergleichen der beiden Anzeigen vorher \/ nachher f\u00e4llt relativ schnell auf: Der Zeilenumbruch nach dem Punkt (Hex 2E) wird als LF (Line Feed) mit Hex 0A gespeichert. Nach dem Laden ist das LF jedoch nicht mehr da und man kann in der Hex Darstellung nur noch den Punkt 2E Hex finden. (Das war \u00fcbrigens der Grund, warum ich einen Punkt als Satzende eingeben, bevor ich die ENTER Taste dr\u00fcckte. So lassen sich die Daten in der Hexdarstellung leichter finden. Man muss nur den Punkt suchen!)<\/p>\n
Problem also: meine Laderoutine doLoadDataFromUri filtert irgendwie den Zeilenumbruch heraus und muss optimiert werden, damit Zeilenumbr\u00fcche richtig dargestellt werden.<\/p>\n
Bisher wurden die Daten satzweise gelesen und an einen Stringbuffer angeh\u00e4ngt:<\/p>\n
\/\/Datei lesen, String aufbauen\r\n<\/em>  while ((s = bufferedReader.readLine()) != null) { \r\n    Log.d <\/em>(\"Akt gelesen\", s); \r\n    sb.append(s); \r\n  }<\/pre>\n
Bei dieser Logik scheint nun aber das LF 0A Hex verloren zu gehen. Ich habe jetzt folgende M\u00f6glichkeiten:<\/p>\n
1) Ich kann jetzt die Dokumentationen von Google oder Java zu Rate ziehen und versuchen herauszufinden, ob es eine L\u00f6sung gibt, wie auch das Stringende 0A Hex in den Ziel-String \u00fcbernommen werden kann<\/p>\n
oder<\/p>\n
2) ich f\u00fcge einfach selbst CF LF (Hex 0D 0A) am jeweiligen Stringende ein. Theoretisch reicht LF Hex 0A, aber es gibt Editoren, die erwarten CR LF als Zeilenende. Wenn ich also beides einf\u00fcge, bin ich auf der garantiert sicheren Seite und muss mir keine Gedanken machen, wenn der Benutzer die Datei wo-auch-immer noch verarbeiten will.<\/p>\n
Aufgrund der einfachen L\u00f6sung w\u00e4hle ich L\u00f6sung 2 und bastele einfach die Schreibroutine etwas um:<\/p>\n
\/\/Datei lesen, String aufbauen\r\n<\/em>while ((s = bufferedReader.readLine()) != null) { \r\n  Log.d <\/em>(\"Akt gelesen\", s);\r\n  s = s + \"\\r\\n\"; \r\n  sb.append(s) ; \r\n}<\/pre>\n
In der Praxis w\u00fcrde ich es allerdings so darstellen:<\/p>\n
\/\/Datei lesen, String aufbauen\r\n<\/em>while ((s = bufferedReader.readLine()) != null) { \r\n  Log.d <\/em>(\"Akt gelesen\", s); \r\n  sb.append(s + \"\\r\\n\"); \r\n}<\/pre>\n
Anschlie\u00dfend nat\u00fcrlich wieder testen. Nun stellt sich heraus: Texte werden mit Umbr\u00fcchen gespeichert und haben keine Ver\u00e4nderung mehr!<\/p>\n
\n
Das Video zu dieser App ist zweigeteilt:<\/p>\n
Teil A: XML Layout<\/p>\n