Android SDK: Erstellen einer Buchscan-App - Anzeigen von Buchinformationen

German (Deutsch) translation by Valentina (you can also view the original English article)

Mit der ZXing-Bibliothek können Sie Android-Anwendungen mit Barcode-Scanfunktion erstellen. In Android SDK: Erstellen eines Barcode-Lesegeräts haben wir das grundlegende Lesen von Barcodes mit der Bibliothek in einer einfachen App implementiert. In dieser Tutorial-Reihe bauen wir auf dem auf, was wir gelernt haben, um eine App zu erstellen, die Bücher scannt und verwandte Informationen über sie von der Google Books-API abruft.

Diese Serie zum Erstellen einer Buchscanner-App besteht aus drei Teilen:

Hier ist eine Vorschau der App, auf die wir hinarbeiten:

Wenn die endgültige App ausgeführt wird, kann der Benutzer Buch-Barcodes scannen. Die App zeigt eine Auswahl von Daten zu den gescannten Büchern an, einschließlich des Kauforts. Die App bietet auch einen Link zur Seite für ein gescanntes Buch in Google Books.

1. Analysieren Sie die Suchergebnisse

Schritt 1

Im letzten Abschnitt haben wir die Google Books-Suchabfrage unter Verwendung der gescannten ISBN (EAN)-Nummer ausgeführt und dann die zurückgegebenen Daten als Zeichenfolge in die App übernommen. Analysieren wir nun die zurückgegebene Zeichenfolge, bei der es sich um einen JSON-Feed handelt. Wir werden dies in der onPostExecute-Methode der von uns erstellten inneren AsyncTask-Klasse tun. Fügen Sie die Methodenübersicht nach der doInBackground-Methode hinzu, die wir das letzte Mal abgeschlossen haben.

1	protected void onPostExecute(String result) {
2	//parse search results
3	}

Wenn Sie einen JSON-Feed oder andere eingehende Daten aus einer externen Datenquelle analysieren, müssen Sie sich zunächst mit der Struktur der eingehenden Daten vertraut machen. In den Abschnitten "Suchen" und "Volume" in der Dokumentation zur Google Books-API finden Sie Informationen zur Struktur der Suchabfrage.

Wir werden die Java JSON-Bibliotheken verwenden, um die Suchergebnisse zu verarbeiten. Fügen Sie Ihrer Hauptaktivitätsklasse die folgenden Importe hinzu.

import java.io.BufferedInputStream;
import java.net.URL;
import java.net.URLConnection;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.net.Uri;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

Schritt 2

Beginnen wir mit der Bearbeitung des Suchergebnisses JSON. Fügen Sie in Ihrer onPostExecute-Methode try- und catch-Blöcke hinzu, um Eingabeausnahmen zu bewältigen.

try{
//parse results
}
catch (Exception e) {
//no result
}

Antworten Sie im catch-Block auf Fälle, in denen kein gültiges Suchergebnis vorliegt.

e.printStackTrace();
titleText.setText("NOT FOUND");
authorText.setText("");
descriptionText.setText("");
dateText.setText("");
starLayout.removeAllViews();
ratingCountText.setText("");
thumbView.setImageBitmap(null);
previewBtn.setVisibility(View.GONE);

Wir setzen einfach alle Elemente der Benutzeroberfläche so, dass angezeigt wird, dass kein gültiges Suchergebnis zurückgegeben wurde. Dies kann passieren, wenn ein gescanntes Buch nicht in Google Books aufgeführt ist oder wenn bei der Eingabe der Daten etwas anderes schief geht.

Schritt 3

Setzen Sie im try-Block die Vorschau-Schaltfläche so, dass sie sichtbar ist, vorausgesetzt, wir haben ein gültiges Ergebnis:

1	previewBtn.setVisibility(View.VISIBLE);

Beginnen Sie nun mit dem Abrufen der JSON-Objekte aus der zurückgegebenen Zeichenfolge.

1	JSONObject resultObject = new JSONObject(result);
2	JSONArray bookArray = resultObject.getJSONArray("items");

Wie Sie der Struktur entnehmen können, die in den Suchanweisungen in der Google Books-API-Dokumentation beschrieben ist, enthält das Abfrageergebnis ein Array mit dem Namen "Elemente", das alle Ergebnisse enthält, die mit der übergebenen ISBN-Nummer übereinstimmen. Da wir nur ein einziges Ergebnis für das gescannte Buch erwarten, erhalten wir das erste Element im Array.

1	JSONObject bookObject = bookArray.getJSONObject(0);

Jetzt benötigen wir das Objekt "volumeInfo", das einige der Daten enthält, die wir anzeigen möchten.

1	JSONObject volumeObject = bookObject.getJSONObject("volumeInfo");

Mit diesem Objekt erhalten wir Zugriff auf die meisten Buchdaten, nach denen wir suchen.

Schritt 4

In einigen Fällen werden Sie feststellen, dass das Google Books-Suchergebnis einige, aber nicht alle Datenelemente zurückgibt. Daher verwenden wir wiederholte try- und catch-Blöcke, um Fälle zu behandeln, in denen einzelne Datenwerte fehlen. Beginnen Sie mit dem Titel.

try{ titleText.setText("TITLE: "+volumeObject.getString("title")); }
catch(JSONException jse){ 
	titleText.setText("");
	jse.printStackTrace(); 
}

Wenn die Zeichenfolge abgerufen werden kann, wird sie in der entsprechenden Text-Ansicht angezeigt. Andernfalls wird eine leere Zeichenfolge angezeigt, wobei der catch-Block es der App ermöglicht, die Suchergebnisse trotz dieses fehlenden Elements weiter zu verarbeiten.

Als nächstes verarbeiten wir den Autor, der als Array dargestellt wird, falls es mehr als einen gibt. Wir werden den gesamten String mit einer Schleife erstellen.

StringBuilder authorBuild = new StringBuilder("");
try{
	JSONArray authorArray = volumeObject.getJSONArray("authors");
	for(int a=0; a<authorArray.length(); a++){
		if(a>0) authorBuild.append(", ");
		authorBuild.append(authorArray.getString(a));
	}
	authorText.setText("AUTHOR(S): "+authorBuild.toString());
}
catch(JSONException jse){ 
	authorText.setText("");
	jse.printStackTrace(); 
}

Autoren werden durch Kommas getrennt, wenn mehrere vorhanden sind. Andernfalls wird der Name des einzelnen Autors angezeigt. Analysieren Sie nun das Veröffentlichungsdatum.

try{ dateText.setText("PUBLISHED: "+volumeObject.getString("publishedDate")); }
catch(JSONException jse){ 
	dateText.setText("");
	jse.printStackTrace(); 
}

Als nächstes werden wir die Beschreibung verarbeiten.

try{ descriptionText.setText("DESCRIPTION: "+volumeObject.getString("description")); }
catch(JSONException jse){ 
	descriptionText.setText("");
	jse.printStackTrace(); 
}

Nun beschäftigen wir uns mit der Sternebewertung. Denken Sie daran, dass wir ein Layout erstellt und ein Array für die Stern-Bildansichten deklariert haben. Kehren Sie für einen Moment zu Ihrer onCreate-Methode zurück und instanziieren Sie das Array nach dem vorhandenen Code.

1	starViews=new ImageView[5];
2	for(int s=0; s<starViews.length; s++){
3	starViews[s]=new ImageView(this);
4	}

Es können maximal fünf Sterne sein. Zurück in onPostExecute nach dem letzten catch-Block, den wir für die Beschreibung hinzugefügt haben, fügen Sie try- und catch-Blöcke für die Sterne hinzu.

try{ 
//set stars
}
catch(JSONException jse){ 
	starLayout.removeAllViews();
	jse.printStackTrace(); 
}

Wenn wir die Anzahl der Sterne abrufen, die dem Buch zugewiesen wurden, fügen wir die Bildansichten dynamisch zu dem Layout hinzu, das wir für die Sternebewertung erstellt haben. Wenn die Sternebewertungsnummer nicht abgerufen werden kann, werden alle zuvor hinzugefügten Ansichten im catch-Block entfernt. Rufen Sie in diesem try-Block die Anzahl der Sterne aus dem zurückgegebenen JSON ab und wandeln Sie sie in eine Ganzzahl um.

1	double decNumStars = Double.parseDouble(volumeObject.getString("averageRating"));
2	int numStars = (int)decNumStars;

Legen Sie die Anzahl der Sterne fest, die derzeit als Layoutobjekt-Tag angezeigt werden. Wir werden dies später verwenden, wenn wir uns mit dem Speichern des App-Status befassen. Entfernen Sie alle vorhandenen Ansichten aus dem Layout für wiederholte Scans.

1	starLayout.setTag(numStars);
2	starLayout.removeAllViews();

Jetzt können wir einfach eine Schleife erstellen, um die relevante Anzahl von Sternen hinzuzufügen.

1	for(int s=0; s<numStars; s++){
2	starViews[s].setImageResource(R.drawable.star);
3	starLayout.addView(starViews[s]);
4	}

Denken Sie daran, dass wir das Sternbild beim letzten Mal zu den Anwendungszeichnungen hinzugefügt haben. Nach dem catch-Block des Sternabschnitts können wir uns mit der Bewertung befassen.

try{ ratingCountText.setText(" - "+volumeObject.getString("ratingsCount")+" ratings"); }
catch(JSONException jse){ 
	ratingCountText.setText("");
	jse.printStackTrace(); 
}

Lassen Sie uns nun überprüfen, ob das Buch eine Vorschau in Google Books enthält. Stellen Sie die Vorschau-Schaltfläche entsprechend ein oder aus.

try{
	boolean isEmbeddable = Boolean.parseBoolean
		(bookObject.getJSONObject("accessInfo").getString("embeddable"));
	if(isEmbeddable) previewBtn.setEnabled(true);
	else previewBtn.setEnabled(false);
}
catch(JSONException jse){ 
	previewBtn.setEnabled(false);
	jse.printStackTrace(); 
}

Wir werden später darauf eingehen, was passiert, wenn Sie auf die Vorschau-Schaltfläche klicken. Rufen Sie als Nächstes die URL für die Buchseite in Google Books ab und legen Sie sie als Tag für die Link-Schaltfläche fest.

try{
	linkBtn.setTag(volumeObject.getString("infoLink"));
	linkBtn.setVisibility(View.VISIBLE);
}
catch(JSONException jse){ 
	linkBtn.setVisibility(View.GONE);
	jse.printStackTrace(); 
}

Wir werden später darauf klicken. Die einzige verbleibende Information, die wir noch verarbeiten möchten, ist das etwas komplexere Miniaturbild. Wir möchten eine zusätzliche AsyncTask-Klasse verwenden, um sie im Hintergrund abzurufen.

2. Rufen Sie das Miniaturbild ab

Schritt 1

Fügen Sie nach der Klasse "GetBookInfo" eine weitere hinzu, um die Miniaturansicht des Buches abzurufen.

1	private class GetBookThumb extends AsyncTask<String, Void, String> {
2	//get thumbnail
3	}

Wir übergeben die Miniaturbild-URL-Zeichenfolge von der anderen AsyncTask, wenn wir sie vom JSON abrufen. Fügen Sie in dieser neuen AsyncTask-Klasse die Methode doInBackground hinzu.

1	@Override
2	protected String doInBackground(String... thumbURLs) {
3	//attempt to download image
4	}

Schritt 2

Fügen Sie in doInBackground try- und catch-Blöcke für E/A-Ausnahmen hinzu.

try{
//try to download
}
catch(Exception e) {
	e.printStackTrace();
}

Versuchen Sie im try-Block, eine Verbindung über die übergebene Miniaturbild-URL herzustellen.

1	URL thumbURL = new URL(thumbURLs[0]);
2	URLConnection thumbConn = thumbURL.openConnection();
3	thumbConn.connect();

Holen Sie sich jetzt Eingabe und gepufferte Streams.

1	InputStream thumbIn = thumbConn.getInputStream();
2	BufferedInputStream thumbBuff = new BufferedInputStream(thumbIn);

Wir möchten das Bild als Bitmap in die App bringen. Fügen Sie daher oben in der Aktivitätsklassendeklaration eine neue Instanzvariable hinzu.

1	private Bitmap thumbImg;

Zurück in doInBackground für die "GetBookThumb"-Klasse lesen Sie nach dem Erstellen des gepufferten Eingabestreams das Bild in diese Bitmap.

1	thumbImg = BitmapFactory.decodeStream(thumbBuff);

Schließen Sie die Streams.

1	thumbBuff.close();
2	thumbIn.close();

Geben Sie nach dem catch-Block eine leere Zeichenfolge zurück, um die Methode abzuschließen.

1	return "";

Fügen Sie nach doInBackground die onPostExecute-Methode hinzu, um das heruntergeladene Bild anzuzeigen.

1	protected void onPostExecute(String result) {
2	thumbView.setImageBitmap(thumbImg);
3	}

3. Führen Sie die Abruf- und Analyseklassen aus

Schritt 1

Lassen Sie uns nun diese Stränge zusammenziehen. Erstellen Sie in Ihrer onActivityResult-Methode nach der Zeile, in der Sie die Suchabfragezeichenfolge erstellt haben, eine Instanz der AsyncTask-Klasse und führen Sie sie aus, um die Suchergebnisse abzurufen.

1	new GetBookInfo().execute(bookSearchString);

Fügen Sie in der onPostExecute-Methode der "GetBookInfo" -Klasse nach dem catch-Block für die Link-Schaltfläche einen letzten Abschnitt zum Abrufen der Miniaturansicht mithilfe der JSON-Daten und der anderen AsyncTask-Klasse hinzu.

try{ 
	JSONObject imageInfo = volumeObject.getJSONObject("imageLinks");
	new GetBookThumb().execute(imageInfo.getString("smallThumbnail"));
}
catch(JSONException jse){ 
	thumbView.setImageBitmap(null);
	jse.printStackTrace();
}

4. Behandeln Sie die verbleibenden Klicks

Schritt 1

Lassen Sie uns mit den Vorschau- und Link-Schaltflächen umgehen. Beginnen Sie mit der Link-Schaltfläche. Wir haben die Klasse bereits als Klick-Listener für die Schaltflächen festgelegt. Fügen Sie daher Ihrer onClick-Methode nach der Bedingung für die Scan-Schaltfläche einen neuen Abschnitt hinzu.

else if(v.getId()==R.id.link_btn){
	//get the url tag
	String tag = (String)v.getTag();
	//launch the url
	Intent webIntent = new Intent(Intent.ACTION_VIEW);
	webIntent.setData(Uri.parse(tag));
	startActivity(webIntent);
}

Dieser Code ruft die URL aus dem Button-Tag ab, das wir bei der Verarbeitung des JSON festgelegt haben. Der Code startet dann den Link im Browser.

Um die Vorschau zu starten, benötigen wir die Buch-ISBN-Nummer. Kehren Sie für einen Moment zur onActivityResult-Methode zurück. Fügen Sie vor der Zeile, in der Sie die Suchabfragezeichenfolge erstellt haben, eine Zeile ein. Legen Sie die gescannte ISBN als Tag für die Vorschau-Schaltfläche fest.

1	previewBtn.setTag(scanContent);

Fügen Sie nun in onClick eine Bedingung für die Vorschau-Schaltfläche hinzu, in der Sie das Tag abrufen.

1	else if(v.getId()==R.id.preview_btn){
2	String tag = (String)v.getTag();
3	//launch preview
4	}

Schritt 2

Wir werden eine neue Aktivität für die Buchvorschau erstellen. Fügen Sie Ihrem Projekt eine neue Klasse im selben Paket wie die Hauptaktivität hinzu und nennen Sie sie "EmbeddedBook". Geben Sie Ihrer Klasse den folgenden Überblick.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import android.app.Activity;
import android.os.Bundle;
import android.webkit.WebView;

public class EmbeddedBook extends Activity {

	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
	}
}

Erstellen Sie eine neue Layoutdatei im Ordner "res/layout" Ihrer App und geben Sie ihr den Namen "embedded_book.xml". Geben Sie das folgende Layout ein.

1	<WebView xmlns:android="https://schemas.android.com/apk/res/android"
2	android:id="@+id/embedded_book_view"
3	android:layout_width="fill_parent"
4	android:layout_height="fill_parent" />

Wir werden die Buchvorschau in der WebView präsentieren. Legen Sie dies in der neuen Klasse als Inhaltsansicht in onCreate nach dem vorhandenen Code fest.

1	setContentView(R.layout.embedded_book);

Fügen Sie oben in der Klasse eine Instanzvariable hinzu.

1	private WebView embedView;

Holen Sie sich in onCreate einen Verweis auf die WebView, die wir in das Layout aufgenommen haben.

1	embedView = (WebView)findViewById(R.id.embedded_book_view);

Stellen Sie ein, dass JavaScript aktiviert ist.

1	embedView.getSettings().setJavaScriptEnabled(true);

Wenn wir die Aktivität starten, übergeben wir die ISBN. Rufen Sie diese übergebenen Daten als nächstes in onCreate ab.

1	Bundle extras = getIntent().getExtras();

Überprüfen Sie nun, ob wir Extras haben.

1	if(extras !=null) {
2	//get isbn
3	}

Versuchen Sie innerhalb der Bedingung, die ISBN abzurufen.

1	String isbn = extras.getString("isbn");

Wir werden den WebView-Inhalt in eine HTML-formatierte Asset-Datei aufnehmen. Fügen Sie try- und catch-Blöcke zum Laden hinzu.

try{
//load asset
}
catch(IOException ioe){
	embedView.loadData
	("<html><head></head><body>Whoops! Something went wrong.</body></html>", 
		"text/html", "utf-8");
	ioe.printStackTrace();
}

Wenn die Datei nicht geladen werden kann, wird eine Fehlermeldung ausgegeben. Wir werden bald zum try-Block zurückkehren. Erstellen Sie zunächst eine neue Datei im Ordner "Assets" Ihrer App und nennen Sie sie "embedded_book_page.html". Suchen Sie die neue Datei in Ihrem Paket-Explorer, klicken Sie mit der rechten Maustaste und wählen Sie "Öffnen mit" und dann "Texteditor". Geben Sie den folgenden Code ein.

<html xmlns="http://www.w3.org/1999/xhtml">
	<head>
		<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
		<title>Google Books Embedded Viewer API Example</title>
		<script type="text/javascript" src="https://www.google.com/jsapi"></script>
		<script type="text/javascript">
		google.load("books", "0");

		function initialize() {
			var viewer = new google.books.DefaultViewer(document.getElementById('viewerCanvas'));
			viewer.load('ISBN:$ISBN$');
		}

		google.setOnLoadCallback(initialize);
		</script>
	</head>
	<body>
		<div id="viewerCanvas" style="width: 600px; height: 500px"></div>
	</body>
</html>

Dies ist der Standard-Markup-Code, der zum Anzeigen einer Google Books-Vorschau mit der Embedded Viewer-API verwendet wird. Beachten Sie, dass die Seite "$ISBN$" enthält. Wir werden dies verwenden, um die ISBN-Nummer aus der Aktivität zu übergeben.

Zurück zum try-Block in Ihrer "EmbeddedBook" -Klasse. Versuchen Sie, die Seite mit dem folgenden Algorithmus zu laden.

InputStream pageIn = getAssets().open("embedded_book_page.html");
BufferedReader htmlIn = new BufferedReader(new InputStreamReader(pageIn));
StringBuilder htmlBuild = new StringBuilder("");
String lineIn;
while ((lineIn = htmlIn.readLine()) != null) {
	htmlBuild.append(lineIn);
}
htmlIn.close();

Übergeben Sie als Nächstes die ISBN und ersetzen Sie den Abschnitt, den wir dafür in den HTML-Code aufgenommen haben.

1	String embeddedPage = htmlBuild.toString().replace("$ISBN$", isbn);

Schließen Sie die neue Aktivität ab, indem Sie die Seite laden.

1	embedView.loadData(embeddedPage, "text/html", "utf-8");

Schritt 3

Zurück in der onClick-Methode der Hauptaktivitätsklasse starten Sie in dem bedingten Block, den Sie für die Vorschau-Schaltfläche hinzugefügt haben, nach der Zeile, in der Sie das Tag abgerufen haben, die neue Aktivität und übergeben Sie die ISBN.

1	Intent intent = new Intent(this, EmbeddedBook.class);
2	intent.putExtra("isbn", tag);
3	startActivity(intent);

Fügen Sie die neue Klasse nach dem Hauptaktivitätselement zu Ihrer Anwendungsmanifestdatei hinzu.

1	<activity android:name="com.example.barcodescanningapp.EmbeddedBook" />

Ändern Sie den Paketnamen gegebenenfalls nach Ihren Wünschen.

5. Behalten Sie den Anwendungsstatus bei

Schritt 1

Sie können die App zu diesem Zeitpunkt ausführen und sie sollte funktionieren. Lassen Sie uns jedoch zuerst dafür sorgen, dass sich der Anwendungsstatus ändert. Fügen Sie in Ihrer Hauptaktivitätsklasse die folgende Methode hinzu.

protected void onSaveInstanceState(Bundle savedBundle) {
	savedBundle.putString("title", ""+titleText.getText());
	savedBundle.putString("author", ""+authorText.getText());
	savedBundle.putString("description", ""+descriptionText.getText());
	savedBundle.putString("date", ""+dateText.getText());
	savedBundle.putString("ratings", ""+ratingCountText.getText());
	savedBundle.putParcelable("thumbPic", thumbImg);
	if(starLayout.getTag()!=null)
		savedBundle.putInt("stars", Integer.parseInt(starLayout.getTag().toString()));
	savedBundle.putBoolean("isEmbed", previewBtn.isEnabled());
	savedBundle.putInt("isLink", linkBtn.getVisibility());
	if(previewBtn.getTag()!=null)
		savedBundle.putString("isbn", previewBtn.getTag().toString());
}

Wir werden nicht näher auf das Speichern des Status eingehen, da dies nicht der Schwerpunkt dieses Tutorials ist. Sehen Sie sich den Code an, um sicherzustellen, dass Sie ihn verstehen. Wir speichern einfach die angezeigten Daten, damit wir sie beibehalten können, wenn sich der Anwendungsstatus ändert. Rufen Sie in onCreate nach dem vorhandenen Code diese Informationen ab.

if (savedInstanceState != null){
	authorText.setText(savedInstanceState.getString("author"));
	titleText.setText(savedInstanceState.getString("title"));
	descriptionText.setText(savedInstanceState.getString("description"));
	dateText.setText(savedInstanceState.getString("date"));
	ratingCountText.setText(savedInstanceState.getString("ratings"));
	int numStars = savedInstanceState.getInt("stars");//zero if null
	for(int s=0; s<numStars; s++){
		starViews[s].setImageResource(R.drawable.star);
		starLayout.addView(starViews[s]);
	}
	starLayout.setTag(numStars);
	thumbImg = (Bitmap)savedInstanceState.getParcelable("thumbPic");
	thumbView.setImageBitmap(thumbImg);
	previewBtn.setTag(savedInstanceState.getString("isbn"));
	
	if(savedInstanceState.getBoolean("isEmbed")) previewBtn.setEnabled(true);
	else previewBtn.setEnabled(false);
	if(savedInstanceState.getInt("isLink")==View.VISIBLE) linkBtn.setVisibility(View.VISIBLE);
	else linkBtn.setVisibility(View.GONE);
	previewBtn.setVisibility(View.VISIBLE);
}

Auch hier werden wir nicht ins Detail gehen. Der Code führt einfach das aus, was der Code bereits unmittelbar nach dem Scannen tut. In diesem Fall folgt es einer Statusänderung. Erweitern Sie das Eröffnungs-Tag Ihres Hauptaktivitätselements im Projektmanifest, um Konfigurationsänderungen zu verarbeiten.

1	android:configChanges="orientation\|keyboardHidden\|screenSize"

Damit ist die App fertig! Sie sollten es an dieser Stelle ausführen können. Drücken Sie beim Start die Taste und scannen Sie ein Buch. Wenn das Buch in Google Books aufgeführt ist, sollten die relevanten Informationen in der Benutzeroberfläche angezeigt werden. Wenn bestimmte Datenelemente fehlen, sollte die App die anderen weiterhin anzeigen. Wenn eine Vorschau verfügbar ist, sollte die Vorschau-Schaltfläche aktiviert sein und die eingebettete Buchaktivität starten.

Abschluss

In dieser Serie haben wir auf der Grundlage des Android SDK aufgebaut: Erstellen eines Barcode-Scanners, um eine Buchscanner-App in Verbindung mit der ZXing-Scanbibliothek und der Google Books-API zu erstellen. Experimentieren Sie mit der App, indem Sie versuchen, verschiedene Datenelemente aus dem zurückgegebenen JSON-Feed abzurufen und anzuzeigen, oder indem Sie auf Scans verschiedener Barcode-Typen und nicht nur auf EANs reagieren. Die Verwendung externer Ressourcen über APIs ist eine Schlüsselkompetenz in jeder Entwicklungsdisziplin, da Sie vorhandene Daten und Funktionen optimal nutzen können, um sich auf die einzigartigen Details Ihrer eigenen Apps zu konzentrieren.