Android :: JSONViewer

Das folgende Beispiel wurde unter Mac OS X 10.6.8 mit der Java Version 1.6.0_26, Eclipse EE 3.7.1 Indigo und ADT (Android Development Tools) Plugin für Eclipse durchgeführt. Siehe auch Hello World Android unter Linux …

Kofiguration

Im Manifest für Android wird die Berechtigung für den Zugriff auf das weltweite Netz (Zeile 7) konfiguriert.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
  package="de.mgsimon.android.jsonviewer" android:versionCode="1"
  android:versionName="1.0">
  <uses-sdk android:minSdkVersion="8" />
 
  <uses-permission android:name="android.permission.INTERNET" />
 
  <application android:icon="@drawable/icon" android:label="@string/app_name">
    <activity android:name=".JSONViewerActivity" android:label="@string/app_name">
      <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
      </intent-filter>
    </activity>
  </application>
</manifest>

JSONViewer/AndroidManifest.xml

Layout

Das Layout enthält ein Eingabefeld (EditText) für die URL, ein Button (ImageButton) zum abrufen der URL und ein mehrzeiliges Textfeld (TextView) zum anzeigen.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="fill_parent" android:layout_height="fill_parent">
 
  <LinearLayout android:layout_height="wrap_content"
    android:id="@+id/linearLayoutUrl" android:layout_width="match_parent">
    <EditText android:id="@+id/editTextURL"
      android:layout_height="wrap_content" android:singleLine="true"
      android:layout_width="0dp" android:layout_weight="2">
      <requestFocus></requestFocus>
    </EditText>
    <ImageButton android:id="@+id/imageButtonLoad"
      android:layout_height="wrap_content" android:src="@android:drawable/ic_media_play"
      android:layout_width="0dp" android:layout_weight="1"></ImageButton>
  </LinearLayout>
 
  <ScrollView android:layout_width="fill_parent"
    android:layout_height="wrap_content" android:layout_below="@+id/linearLayoutUrl"
    android:layout_margin="5dip">
 
    <TextView android:id="@+id/textViewContent"
      android:layout_width="fill_parent" android:layout_height="wrap_content"
      android:textAppearance="?android:attr/textAppearanceMedium" />
 
  </ScrollView>
</RelativeLayout>

JSONViewer/res/layout/main.xml

Activity

Die Aktivität JSONViewerActivity erweitert Activity (Zeile 26) und initialisiert notwendige Komponenten in der überschriebene Methode onCreate (Zeile 37). Referenzen zu Elementen des UI werden über findViewById (Zeile 41,43 und 44) gesetzt und dem ImageButton (Zeile 45) wird die aufzurufende Methode für das Event onClick (Zeile 48) überschrieben.

Die Methode onClick – aufgerufen durch Klick auf dem Button – startet mit übergebener URL (Zeile 50) einen Thread (Zeile 51). Die Klasse UrlLoadTask zeigt vor (Zeile 63) dem Thread einen Status an und aktualisiert die Aktivität nach (Zeile 94) dem Thread.

Die Daten werden unabhängig des Threads für die Benutzeroberfläche in der Methode doInBackground (Zeile 69) verarbeitet.

Application not responding (ANR) Meldungen werden nach etwa drei Sekunden geworfen, wenn die Benutzeroberfläche blockiert wird. Alle langläufigen und unbekannten Laufzeiten nebenläufig ausführen, dann klappt es auch ohne ANR.

Im Hintergrund herunterladen (Zeile 71-73), JSONObject erzeugen (Zeile 74) und die TextView aktualisieren (Zeile 97).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

package de.mgsimon.android.jsonviewer;
 
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
 
import org.apache.http.HttpResponse;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import org.json.JSONException;
import org.json.JSONObject;
 
import android.app.Activity;
import android.app.ProgressDialog;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.ImageButton;
import android.widget.TextView;
 
public class JSONViewerActivity extends Activity {
 
  private EditText mEditTextUrl;
  private ImageButton mImageButtonLoad;
  private TextView mTextViewContent;
  private URI mUri;
 
  private ProgressDialog mProgressDialog;
 
  /** Called when the activity is first created. */
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
 
    mEditTextUrl = (EditText) findViewById(R.id.editTextURL);
    mEditTextUrl.setText("http://mgsimon.appspot.com/aboutmyrequest");
    mTextViewContent = (TextView) findViewById(R.id.textViewContent);
    mImageButtonLoad = (ImageButton) findViewById(R.id.imageButtonLoad);
    mImageButtonLoad.setOnClickListener(new View.OnClickListener() {
 
      @Override
      public void onClick(View v) {
        try {
          mUri = new URI(mEditTextUrl.getText().toString());
          new UrlLoadTask().execute(mUri);
        } catch (URISyntaxException e) {
          e.printStackTrace();
          mTextViewContent.setText(e.getMessage());
        }
      }
    });
  }
 
  private class UrlLoadTask extends AsyncTask<URI, Void, JSONObject> {
 
    @Override
    protected void onPreExecute() {
      mProgressDialog = ProgressDialog.show(JSONViewerActivity.this, "",
          "Loading. Please wait...", true);
    }
 
    @Override
    protected JSONObject doInBackground(URI... uris) {
      try {
        HttpClient client = new DefaultHttpClient();
        HttpGet get = new HttpGet(uris[0]);
        HttpResponse response = client.execute(get);
        JSONObject jso = new JSONObject(EntityUtils.toString(response
            .getEntity()));
        return (jso);
      } catch (ClientProtocolException e) {
        e.printStackTrace();
        mTextViewContent.setText(e.getMessage());
      } catch (IOException e) {
        e.printStackTrace();
        mTextViewContent.setText(e.getMessage());
      } catch (ParseException e) {
        e.printStackTrace();
        mTextViewContent.setText(e.getMessage());
      } catch (JSONException e) {
        e.printStackTrace();
        mTextViewContent.setText(e.getMessage());
      }
      return null;
    }
 
    @Override
    protected void onPostExecute(JSONObject jso) {
      try {
        if (jso != null)
          mTextViewContent.setText(jso.toString(4));
      } catch (JSONException e) {
        e.printStackTrace();
        mTextViewContent.setText(e.getMessage());
      }
      mProgressDialog.dismiss();
    }
  }
}

JSONViewer/src/de.mgsimon.android.jsonviewer/JSONViewerActivity.java

Google App Engine JSON :: AboutMyRequest

Viele Wege führen nach JSON, hier ein kleines Beispiel in Java …

Das folgende Beispiel wurde unter Mac OS X 10.6.8 mit der Java Version 1.6.0_26, Eclipse EE 3.7.1 Indigo und Google Plugin für Eclipse 2.4.1 durchgeführt. Siehe auch Hello World Google App Engine …

AboutMyRequest …

… oder einfach über mein Request soll als kleines Beispiel die Informationen über eine Anfrage zur Anwendung in der Google App Engine in JSON zurück beantworten.

JSON Referenzimplementierung

Im SDK von der Google App Engine sind die Klassen der Referenzimplementierung zur Verarbeitung von JSON im Paket com.google.appengine.repackaged.org.json (appengine-api-labs-1.5.4.jar) vorhanden.

Damit die Dokumenation der Referenzimplementierung von Douglas Crockford in Eclipse verwendet werden kann, können die Quellen unter JSON-java als ZIP-Archiv heruntergeladen werden und dem Projekt hinzugefügt werden.

AboutMyRequestServlet

Ein neues Servlet wird im Google App Engine Projekt bei selektiertem Package über “File / New / Class” mit folgenden Einstellungen erstellt.

Google App Engine JSON :: Eclipse New Java Class

• Name: AboutMyRequestServlet
• Superclass: javax.servlet.http.HttpServlet

In dem folgenden Servlet wird ein JSONObject erzeugt (Zeile 20) und die jeweiligen Header-Informationen hinzugefügt (Zeile 25). Das JSONObject wird mit dem richtigen Media Type (Zeile 27) über Response einfach zum Client gesendet (Zeile 28).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package tld.sld.my.example;
 
import java.io.IOException;
import java.util.Enumeration;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.google.appengine.repackaged.org.json.JSONException;
import com.google.appengine.repackaged.org.json.JSONObject;
 
@SuppressWarnings("serial")
public class AboutMyRequestServlet extends HttpServlet {
 
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
			throws ServletException, IOException {
		JSONObject jsonObject = new JSONObject();
		try {
			Enumeration<String> names = req.getHeaderNames();
			while(names.hasMoreElements()) {
				String name = names.nextElement();
				jsonObject.put(name, req.getHeader(name));
			}
			resp.setContentType("application/json");
			resp.getWriter().print(jsonObject);
		} catch (JSONException e) {
			e.printStackTrace();
		}
	}
 
}

AboutMyRequestServlet.java

Konfiguration

Damit das Servlet im Container bekannt ist (<servlet>) und über eine URL auflösbar ist (<servlet-mapping>), muss folgende Konfiguration in der Datei “war/WEB-INF/web.xml” hinzugefügt werden.

<servlet>
	<servlet-name>AboutMyRequest</servlet-name>
	<servlet-class>tld.sld.my.example.AboutMyRequestServlet</servlet-class>
</servlet>
<servlet-mapping>
	<servlet-name>AboutMyRequest</servlet-name>
	<url-pattern>/aboutmyrequest</url-pattern>
</servlet-mapping>

web.xml

Anschließend kann die Webanwendung über “Run / Run As / Web Application” gestartet werden und lokal über http://localhost:8888/aboutmyrequest getestet werden.

Antworten

Nach erfolgreicher Publizierung in der Google App Engine kann auf das Servlet über http://myappid.appspot.com/aboutmyrequest wie z.B. http://mgsimon.appspot.com/aboutmyrequest zugegriffen werden.

{
    "Accept-Language":"de-de,de;q=0.8,en-us;q=0.5,en;q=0.3",
    "Host":"mgsimon.appspot.com",
    "Accept-Charset":"ISO-8859-1,utf-8;q=0.7,*;q=0.7",
    "X-AppEngine-Country":"DE",
    "User-Agent":"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; de; rv:1.9.2.23) Gecko/20110920 Firefox/3.6.23",
    "Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
}

Antwort einer Anfrage durch Mozilla Firefox unter Mac OS X auf einem MacBook Pro

{
    "Host":"mgsimon.appspot.com",
    "Referer":"http://mgsimon.de/",
    "X-AppEngine-Country":"DE",
    "User-Agent":"Mozilla/5.0 (Linux; U; Android 2.3.3; de-de; HTC_DesireZ_A7272 Build/GRI40) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1"
}

Antwort einer Anfrage durch Browser unter Android auf einem HTC Desire Z

Die Anfrage wird durch die Google App Engine um zusätzliche Informationen wie z.B. die i18n Info “X-AppEngine-Country”:”DE” erweitert.

Weiter …

• rfc4627

Hello World Google App Engine :: Mozilla Firefox

“Hello World” in der Google App Engine, ein erstes kleines Beispiel in Java. Ab in die Cloud, schnell, schneller, am schnellsten …

Das folgende Beispiel wurde unter Mac OS X 10.6.8 mit der Java Version 1.6.0_26, Eclipse EE 3.7.1 Indigo und Google Plugin für Eclipse 2.4.1 durchgeführt.

Für die Verwendung der Google App Engine ist ein Google-Konto und die Anmeldung unter appengine.google.com notwendig.

Einfach mit der E-Mail und dem Passwort anmelden und auf der folgenden Seite über “Create Application” das eigene Konto durch eine Handynummer bestätigen. Eine SMS mit einem Code zur Bestätigung wird unmittelbar an die angegebene Nummer gesendet. Nach der Bestätigung kann die erste Anwendung erstellt werden.

“Application Identifier”, “Application Title, “I accept these terms.” und die Anwendung kann über “Create Application” erstellt werden.

Auf der Suche nach einem noch verfügbarem “Application Identifier” kann der Name des eigenen Google-Kontos verwendet werden, dieser sollten in der Regel für das eigene Konto reserviert sein.

Hello World Google App Engine :: Dashboard

Anwendungen für die Google App Engine können mit dem SDK für Java manuell oder mit etwas mehr Benutzerfreundlichkeit dem Google Plugin in der IDE Eclipse erstellt werden.

Eclipse herunterladen, Archiv extrahieren, Eclipse starten und das Google Repository über “Help / Install New Software… / Add…” mit folgenden Angaben hinzufügen.

• Name: Google
• Location: http://dl.google.com/eclipse/plugin/3.7

Google stellt das Plugin für mehrere Eclipse Versionen (Galileo, Helios, Indigo …) in verschiedene Repositories bereit. Die Adressen für die jeweilige Version sind unter Google Plugin für Eclipse aufgelistet.

Hello World Google App Engine :: Install Available Software

Hello World Google App Engine :: Eclipse Plugin

Hello World

Einfach über “File / New / Project …” ein “Google / Web Application Project” auswählen und durch “Next >” mit folgenden Einstellungen über “Finish” ein neues Projekt erstellen.

• Project name: HelloWorldGoogleAppEngine
• Package: tld.sld.my.example
• Use Google Web Toolkit abwählen

Hello World Google App Engine :: Create Web Application Project

package tld.sld.my.example;
 
import java.io.IOException;
import javax.servlet.http.*;
 
@SuppressWarnings("serial")
public class HelloWorldGoogleAppEngineServlet extends HttpServlet {
	public void doGet(HttpServletRequest req, HttpServletResponse resp)
			throws IOException {
		resp.setContentType("text/plain");
		resp.getWriter().println("Hello, world");
	}
}

Das erste Servlet “Hello World Google App Engine” ohne eine Zeile selbst geschrieben zu haben … ;)

Test

Die Entwicklungsumgebung bietet durch das Google Plugin für Eclipse eine lokale Simulationsumgebung an.

Die Google App Engine Web Anwendung wird bei selektiertem Projekt über “Run / Run As / Web Application” lokal gestartet und im Browser kann über die URL http://localhost:8888/ die folgende Startseite geladen werden.

Hello World Google App Engine :: Hello App Engine

Hello World Google App Engine :: Mozilla Firefox

Damit das erste Beispiel im weltweiten Netz erreichbar ist, muss die Anwendung in die Cloud von Google publiziert werden.

In der Konfigurationsdatei appengine-web.xml unter “war/WEB-INF” die eigene zuvor erstellte Anwendungs-ID (myappid) eintragen.

<?xml version="1.0" encoding="utf-8"?>
<appengine-web-app xmlns="http://appengine.google.com/ns/1.0">
  <application>myappid</application>
  <version>1</version>
 
  <!--
    By default, App Engine sends requests serially to a given web server.
    To allow App Engine to send multiple requests in parallel specify:
 
      <threadsafe>true</threadsafe>
  -->
 
  <!-- Configure java.util.logging -->
  <system-properties>
    <property name="java.util.logging.config.file" value="WEB-INF/logging.properties"/>
  </system-properties>
 
</appengine-web-app>

Das Projekt kann über das Kontextmenü “Google / Deploy to App Engine” zur App Engine von Google übertragen werden.

Anschließend kann auf die Anwendung über http://myappid.appspot.com (myappid = zuvor erstellter Application Identifier) wie z.B. http://mgsimon.appspot.com zugegriffen werden.

Fertig … erst einmal. ;)

Weiter …

• Google App Engine Projekt
• Google App Engine Dokumentation
• Google App Engine Javadoc
• Google App Engine Administration
• Programming Google App Engine (Animal Guide)

Mac OS X :: Boot Android Emulator

Das folgende Beispiel wurde unter Mac OS X – 10.6.4 – Snow Leopard durchgeführt.

Disk Image

Warum ein Disk Image?
Die Quellen der Android-Plattform enthalten Dateien mit gleichen Name, welche sich lediglich durch Groß- / Kleinschreibung unterscheiden. Mac OS X unterscheidet diese im Auslieferungszustand nicht.

Disk Image “android.dmg” für die Android-Quellen mit dem Festplatten-Dienstprogramm unter “Programme / Dienstprogramme” mit folgenden Optionen erstellen.

• Sichern unter: android.dmg
• Name: android
• Größe: Eigene (10,24 GB)
• Format: Mac OS Extended (Groß- / Kleinschreibung und Journaled)

Mac OS X :: Festplatten-Dienstprogramm Image erstellen

Die aktuellen Versionen von Xcode und MacPorts herunterladen, installieren und wie folgt konfigurieren.

• In der Datei “~/.bash_profile” die Umgebungsvariable “PATH” für die MacPorts und “repo” (Repository-Skript) erweitern.

PATH=/opt/local/bin:~/bin:$PATH

• Zusätzliche MacPorts Pakete u.a. für die Versionsverwaltung Git installieren.

$ sudo port install gmake libsdl git-core gnupg

Repository

Das Repository-Skript installieren und auf dem erstellten Disk Image initialisieren. Die anschließende Synchronisation lädt bei einer 20 MB DSL Anbindung in ungefähr einer Stunde (64m22.741s) etwa vier GB Quellen herunter.

$ mkdir ~/bin
$ curl http://android.git.kernel.org/repo > ~/bin/repo
$ chmod a+x ~/bin/repo
$ cd /Volumes/android 
$ repo init -u git://android.git.kernel.org/platform/manifest.git
$ repo sync

Make

Die Quellen der Android Plattform können mit einem einfachen “make” (ca. zwei Stunden (114m23.836s) Mac Book Pro 2.4 GHz) übersetzt werden.

$ make

Emulator

Zu guter letzt kann der Emulator wie folgt gestartet werden.

$ . build/envsetup.sh
$ lunch 1
$ emulator

Mac OS X :: Android Emulator

Und es läuft doch …

Abweichend der Dokumentation auf source.android.com können die aktuellen Android Quellen auch unter Snow Leopard übersetzt werden. :-)

At the moment MacOS 10.6 (“Snow Leopard”) is not supported.

Was sich hinter den Türchen bis jetzt verbag.

• Java 6. Professionell einsteigen
• Java 6 Programmierhandbuch
• Das Google Web Toolkit. schnell + kompakt
• Managed DirectX und C#. Einstieg und professioneller Einsatz
• Dojo Toolkit. schnell + kompakt
• Visual C#

Hol Dir den schwarzen Gürtel in Java.

Nicht nur Java sondern folgende Themen werden durch online Tests vertieft.

Java 5 New Language Features
Java 5 New Base Library Features
Java 5 New Tools and Tool Features
Java SE – Basic
Java SE Core – Intermed
Java SE Base API – Basic
Java SE Base API – Intermed
Java SE Collections
Java SE IO
Java SE NIO
Java SE Networking
Java SE Reflection API
Java SE Tools
Java SE RegEx
Java SE Concurrency – High-Level
Java SE Concurrency – Low-Level
Java SE – Programming Exam
Java ME
OO for Java – Basic
OO – Intermed
Servlet – Basic
Servlet – Intermediate
JSP – Basic
JSP – Intermed
Struts 1 – Basic
Struts 1 – Intermed
Struts Tiles
JSF 1.1 – Basic
Tapestry 4 – Basic
EJB 2 – Basic
EJB 2 – Intermed
EJB 3.0 Basic
JPA Exam
Web Services – Basic
JMS
Spring Core – Basic
Spring Core
Spring MVC
Spring DAO JDBC
XML Core – Basic
XML Programming – Basic
XML DTD
SQL & RDB – Basic
JDBC – Basic
JDBC – Intermed
Hibernate 3 Core – Basic
Hibernate 3 – Core
Hibernate 3 – Entity Associations and Relationships
Hibernate 3 – Inheritance Strategies
Hibernate 3 – Persistent Objects Retrieval
Hibernate 3 – Caching
Hibernate 3 – Transaction & Concurrency
Hibernate 3 – Advanced Lifecycle
Ant – Basic
JUnit – Basic
JUnit – Intermed
JUnit 4
Websphere Application Developer (WSAD)
Log4J
PMD – Basic
UML for Java – Basic
Eclipse RCP – Basic
Ruby – Basic
Maven2 Standard
Maven2 J2EE
Maven2 Developer
Swing – Basic
JGoodies Forms
JGoodies Bindings

Na dann viel Spass beim lernen (JavaBlackBelt)!

1. Das DDL-Skript von 300 auf 301 muss gegenüber die Datenbank ausgeführt werden.
2. Das Webanwendungsverzeichnis in der roller.xml angepasst werden.
3. Die Konfiguration hat sich gegenüber 3.0 geändert, in einer roller-custom.properties werden zukünftig die Einstellungen der roller.properties überschrieben (u.a. Upload- und Indexverzeichis).

Nach der Aktualisierung hatte ich ein Problem mit den zuvor hochgeladenen Dateien, da noch nicht besonders viele Dateien vorhanden waren, habe ich diese einfach erneut hochgeladen.

Fertig, mit der Hoffnung eine stabile Version mit Release Candidate 6 installiert zu haben. :-)

Zu früh gefreut, Weblogeintraege mit enthaltenen Sonderzeichen wie ö,ä,ü können nicht gespeichert werden. :-(

...
JDBCExceptionReporter:logExceptions - SQL Error: 0, SQLState: 01004
JDBCExceptionReporter:logExceptions - Data truncation: Data too long for column 'summary' at row 1
...

Lösung gefunden! :-)
Roller benötigt UTF-8, ältere MySQL Versionen sind auf Latin-1 voreingestellt.

Die Datenbank kann wie folgt von Latin-1 nach UTF-8 konvertiert werden.
Roller (bzw. Tomcat) sollte während der Konvertierung heruntergefahren werden.

1. Dump erzeugen

mysqldump DATENBANK -u USER -p >DATEINAME

2. Dump modifizieren
Suchen und Ersetzen im Datenbankdump nach “latin1″ durch “utf8″.
Am Anfang der Datei

use DATENBANK;

einfügen.

3. Dump konvertieren
Mit folgendem Befehl die Datei nach UTF-8 konvertieren.

iconv -f iso-8859-1 -t utf-8 DATEINAME

4. Dump einspielen

mysql -u USER -p <DATEINAME

Anschließend sollten Weblogeinträge mit Sonderzeichen erstellt werden können! :-)