Twittern kann man überall, doch am bequemsten funktioniert es per Smartphone. Seit der Einführung des neuen Profil-Designs nutzen mehr als 37 Prozent aller Anwender den Dienst per Mobiltelefon. Zeit sich die Möglichkeiten genauer anzuschauen.
README
Dieser Artikel erklärt, wie die Authentifizierung von Twitter über OAuth funktioniert und wie Sie damit eine eigene Android-App schreiben.
Immer mehr Leute loggen sich über offizielle oder inoffizielle Handy-Anwendungen wie Seesmic, TweetDeck und Twitdroid bei Twitter ein. Durch die App Stores gibt es zurzeit einen rapiden Anstieg an Entwicklern, die kostenlose oder kostenpflichtige Anwendungen für Twitter für zahlreiche mobile Plattformen schreiben. Android gehört aufgrund seiner umfassenden Dokumentation, seiner Offenheit und seines ständig wachsenden Marktanteils zweifellos zu den aufregendsten darunter.
Dieser Artikel beschreibt den allerwichtigsten, jedoch etwas kniffligen ersten Schritt, den Sie zur Entwicklung einer eigenen Twitter-App für Android benötigen: die Authentifizierung. Der in den Listings abgedruckte Code ist auch auf Github [1] verfügbar.
Voraussetzungen
Haben Sie in der Android-Entwicklung noch keine Erfahrung, empfehle ich Ihnen die Bücher "Hello, Android" von Ed Burnette und "Beginning Android 2" von Mark Murphy sowie den Android Developer’s Guide [2]. Diese geben einen ausgezeichneten Überblick über die Plattform mit einer Vielzahl von Beispielen und Best-Practice-Techniken.
Dieser Artikel setzt voraus, dass Sie die Android-Entwicklungsumgebung (SDK) und Eclipse bereits heruntergeladen und installiert haben, sowie ein Android Virtual Device (AVD) unter Android 2.2 laufen lassen. Mehr dazu erfahren Sie unter "Hello, World" im Android Developer’s Guide. Die Ausführungen beruhen auf der Android 2.2 Code-Bibliothek, lassen sich mit geringen Anpassungen aber auch auf älteren Versionen anwenden. Android 2.x ist zurzeit auf über 70% aller Android-Geräte installiert [3].
Für die geplante App benutzen wir eine frei verfügbare Java-Client-Bibliothek namens Twitter4J [4]. Sie übernimmt die Mehrheit der Datenanfragen und der Datenbearbeitung. Weitere Informationen zur Twitter-API finden Sie auf meiner Entwickler-Website [5] oder in meinem Buch "The Developer’s Guide to Social Programming".
Twitter OAuth
OAuth, ausgesprochen "oh-auth", ist ein Authentisierungsmechanismus. Er wird benutzt, damit Benutzer ihren Benutzernamen und ihr Passwort nicht an einzelne Anwendungen weitergeben müssen. Bis zum 1. September erlaubte Twitter die Grund-Authentifizierung für Anwendungen von Drittanbietern. Heute führt der einzige Weg über OAuth, wenn Sie eine Funktion wie Tweeting, Versand von Direktnachrichten oder das Abrufen einer Timeline ausführen möchten (oder über xAuth, falls Sie die Genehmigung dafür bei Twitter beantragen). OAuth verwendet verschiedene Schlüssel und Tokens, um Anwendungen (Consumer Key und Consumer Secret) oder Benutzer (Request Token, Access Token und Token Secret) zu identifizieren. Wie das funktioniert, zeigt Abbildung 1.
In diesem Workflow sucht die Anwendung zuerst nach einem Access Token und Token Secret im sicheren Datenspeicher des Handys. Wenn dieser vorhanden ist, ruft sie die angeforderte Twitter-Ressource ab. Wenn nicht, leitet sie ein Authorisierungsverfahren ein und der Benutzer wird zu einer Authorisierungs-URL weitergeleitet, wobei ein Request Token, sowie Consumer Key und Consumer Secret der Anwendung verwendet werden. Dann gibt der Benutzer seinen Benutzernamen und sein Passwort auf einer sicheren Twitter Web-Oberfläche ein. Wird er zugelassen, erhält die Anwendung ein Access Token und ein Token Secret, die auf unbestimmte Zeit (oder bis zum manuellen Widerrufen) gespeichert werden. Falls der Benutzer der Anwendung keinen Zugriff gewährt, fordert ihn dieser Workflow solange erneut auf, bis er den Zugriff erlaubt.
Unsere Beispielanwendung, die wir in diesem Artikel erstellen, implementiert diesen Workflow über zwei Aktivitäten: eine für das Abrufen der Home-Timeline des Benutzers und eine für die Authorisierungsschritte. Dazu kommt eine App für Persistenz und die Klasse OAuthHelper. Aber zuerst benötigen wir eine Twitter-Anwendung, in unserem Beispiel Potta.
Unsere Twitter App
Potta steht für die "Plain Ol‘ Twitter" Testapp. Natürlich können Sie sich während der Registrierung einen eigenen pfiffigen Namen ausdenken. Besuchen Sie dazu http://dev.twitter.com/apps/new, um die neue Anwendung zu registrieren, und benutzen Sie folgende Einstellungen:
- Application Name: der Name Ihrer Anwendung
- Description: Plain ol‘ Twitter Testanwendung für Ihr Android-Handy.
- Application Website: Eine gültige URL
- Organization: Ihr Name
- Application Type: Browser
- Callback URL: URL/authentication
- Default Access Type: Read-Only
- Application Icon: Ihr Icon
Nach erfolgreicher Registrierung erhalten Sie Ihren Consumer Key und das Consumer Secret, die wir weiter unten benötigen. Diese Schlüssel ändern Sie wenn nötig im Application Settings Panel, wenn zum Beispiel die Sicherheit Ihrer Anwendung gefährdet wäre. Beachten Sie, dass die Callback-URL keine echte URL ist – sie wird nur von unserem eigenen WebViewClient gebraucht. Für diese Beispielanwendung fordern wir nur Read-Only-Rechte an. Für eine echte Anwendung benötigen Sie Read-Write-Rechte, damit die Timeline des Benutzers aktualisiert wird.
Das Eclipse-Projekt
Sind alle Voraussetzungen erfüllt, erstellen Sie mit Hilfe des New Project Wizard in Eclipse ein neues Android-Projekt. Verwenden Sie dazu die folgenden Einstellungen:
- Project Name: Potta
- Build Target: Google APIs (Android 2.2)
- Application Name: Potta
- Package Name: app.potta
- Create Activity: HomeListActivity
- Min SDK Version: 8
Einmal erstellt, erscheint wahrscheinlich die Fehlermeldung, dass Eclipse R.java nicht finden kann. Dieses Problem beheben Sie, indem Sie in Eclipse auf Project | Clean? klicken, um das Projekt aufzufrischen. Anschließend bewegen Sie die neu erstellte HomeListActivity.java vom app.potta-Paket in ein neues Paket namens app.potta.activities und bestätigen dabei alle vorgeschlagenen Code-Fixes.
Als nächstes öffnen Sie AndroidManifest.xml und überprüfen, ob im Manifest-Tag des Headers das Paket auf app.potta und im ersten <activity>-Tag android:name auf .activities.HomeListActivity eingestellt ist. Wenn nicht, nehmen Sie die nötigen Änderungen vor. Diese sind nicht nur von ästhetischer Natur, sondern sehr nützliche Techniken. Testen Sie nun, ob Sie die Anwendung an der gewünschten Stelle mit der Android-Version von "Hello, World" ausführen können.
Für den Fall, dass Sie auch Google-spezifische Funktionen, wie Google-Maps in Ihrer Anwendung integrieren wollen, verwenden wir Google APIs Build-Target. Abbildung 2 verschafft einen Überblick über die im Projekt benutzten Java-Dateien mit den dazugehörigen Attributen und Methoden als UML-Diagramm.
Twitter4J
Twitter4J [4] ist eine inoffizielle Java-Bibliothek für die Twitter-API, die 100 Prozent auf Java basiert und über eingebaute OAuth-Unterstützung verfügt. Sie hat keine weiteren Abhängigkeiten wie zum Beispiel jTwitter oder Java Twitter.
Laden Sie die aktuellste stabile Version von Twitter4J (zurzeit 2.1.x) herunter, und legen Sie die Datei twitter4j-core-2.1.x-SNAPSHOT.jar in einem neuen lib-Verzeichnis im Wurzelverzeichnis des Projekts ab. Klicken Sie mit der rechten Maustaste auf das Projekt Potta, dann auf Properties und wechseln Sie in das Menü Java Build Path. Stellen Sie sicher, dass Sie die Twitter4J Bibliothek als JAR in der Registerkarte Bibliotheken hinzugefügt haben. Und schon haben wir Twitter!
OAuthHelper-Klasse
OAuthHelper enthält den gesamten Code für die Interaktion mit der Twitter4J-Bibliothek, und wird von der PottaApplication-Klasse verwendet. Die Klasse verwendet Ihren Consumer Key und Ihr Consumer Secret, die Sie zuvor notiert haben. Kopieren Sie diese in eine neue Datei mit dem Namen oauth.properties und legen Sie die Datei im Verzeichnis raw innerhalb des res-Verzeichnisses ab. Zusammen mit allen anderen Ressourcen wie zum Beispiel Bildern wird diese Datei durch R.java kompiliert und der Anwendung mit Hilfe von R.raw.oauth zur Verfügung gestellt. Die Datei enthält nur die zwei Schlüssel-Wert-Paare:
consumer_key=XXXX consumer_secret=XXXX
Die Klasse OAuthHelper bringen wir im Paket app.potta.authorization unter. Den nötigen Code zeigt Listing 1.
package app.potta.authorization;
import java.io.InputStream;
import java.util.Properties;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.http.AccessToken;
import twitter4j.http.RequestToken;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.util.Log;
import app.potta.R;
public class OAuthHelper {
private String consumerKey;
private String consumerSecret;
private Context context;
private SharedPreferences preferences;
private AccessToken accessToken;
private static final String ACCESS_TOKEN = "access_token";
private static final String TOKEN_SECRET = "token_secret";
private static final String APPLICATION_PREFERENCES = "app_preferences";
public OAuthHelper(Context context) {
this.context = context;
preferences = context.getSharedPreferences(APPLICATION_PREFERENCES,
Context.MODE_PRIVATE);
loadConsumerKeys();
loadAccessToken();
}
private void loadConsumerKeys() {
try {
Properties props = new Properties();
InputStream stream = context.getResources()
.openRawResource(R.raw.oauth);
props.load(stream);
this.consumerKey = (String)props.getProperty("consumer_key");
this.consumerSecret = (String)props.getProperty("consumer_secret");
} catch (Exception e) {
throw new RuntimeException("Kann Consumer Key und Consumer Secret nicht laden.", e);
}
}
private void loadAccessToken() {
String accessToken = preferences.getString(ACCESS_TOKEN, null);
String tokenSecret = preferences.getString(TOKEN_SECRET, null);
if (null != accessToken && null != tokenSecret) {
this.accessToken = new AccessToken(accessToken, tokenSecret);
} else {
this.accessToken = null;
}
}
public boolean isAuthorized() { return accessToken != null; }
public Twitter loadTwitter() {
if (isAuthorized()) {
return new TwitterFactory().getOAuthAuthorizedInstance(consumerKey,
consumerSecret, accessToken);
} else {
return new TwitterFactory().getOAuthAuthorizedInstance(consumerKey,
consumerSecret);
}
}
public String getAuthorizationUrl(String application, Twitter twitter) {
try {
RequestToken requestToken = twitter.getOAuthRequestToken();
return requestToken.getAuthorizationURL();
} catch (TwitterException e) {
Log.e(application, "Kann Authorisierungs-URL nicht erhalten.");
return null;
}
}
public void setAccessToken(Twitter twitter) {
try {
AccessToken accessToken = twitter.getOAuthAccessToken();
storeAccessToken(accessToken);
} catch (TwitterException e) {
throw new RuntimeException("Kann den Benutzer nicht authorisieren.", e);
}
}
private void storeAccessToken(AccessToken accessToken) {
Editor editor = preferences.edit();
editor.putString(ACCESS_TOKEN, accessToken.getToken());
editor.putString(TOKEN_SECRET, accessToken.getTokenSecret());
editor.commit();
this.accessToken = accessToken;
}
}
Die loadTwitter()-Methode sendet entweder ein authenticated oder ein unauthenticated Twitter-Objekt zurück, abhängig davon, ob der Benutzer für dieses Konto authentifiziert ist, oder nicht. Die Methoden loadAccessToken(), setAccessToken() und storeAccessToken() handhaben das AccessToken, das über Twitter4J abgefragt und in dem Android-Datenspeicher gespeichert wird. Die getAuthorizationUrl() sendet eine Zeichenkette aufgrund des RequestToken, und ein unauthenticated Twitter-Objekt zurück.
PottaApplication
Durch die Erweiterung der allgemeinen Android Anwendungsklasse bekommt Potta Persistenz. Das nützt uns dabei, das OAuthHelper und das Twitter-Objekt zu referenzieren. Da das Twitter-Objekt sich in einem von zwei Zuständen befinden kann, können wir PottaApplication für die Speicherung seiner Referenz, sowie für die Verarbeitung von unserem Access Token und Token Secret verwenden. Zudem braucht die Datei AndroidManifest.xml einen Eintrag, der dem Compiler mitteilt, dass wir statt einer regulären Application nun eine PottaApplication verwenden. Mehr dazu im entsprechenden Abschnitt dieses Artikels. Die Klasse PottaApplication zeigt Listing 2.
package app.potta;
import twitter4j.Twitter;
import android.app.Application;
import android.widget.Toast;
import app.potta.authorization.OAuthHelper;
public class PottaApplication extends Application {
private String APP = "Potta";
private OAuthHelper oAuthHelper;
private Twitter twitter;
@Override
public void onCreate() {
super.onCreate();
oAuthHelper = new OAuthHelper(this);
twitter = oAuthHelper.loadTwitter();
}
public Twitter getTwitter() { return twitter; }
public OAuthHelper getOAuthHelper() { return oAuthHelper; }
public String getAuthorizationUrl() {
this.twitter = oAuthHelper.loadTwitter();
return oAuthHelper.getAuthorizationUrl(APP, twitter);
}
public void setAccessToken() { oAuthHelper.setAccessToken(twitter); }
public Toast makeToast(String text) { return Toast.makeText(this, text,
Toast.LENGTH_LONG); }
}
Die Klasse ist relativ einfach. Sie enthält zwei Zugriffsmethoden genannt getTwitter() und getOAuthHelper() zum Extrahieren der Objekte, die durch die onCreate()-Methode entstehe. Die Methode wird aufgerufen, wenn wir die Anwendung zum ersten Mal laden. Die Methode getAuthorizationUrl() setzt das Twitter-Objekt zurück (das ist dann nützlich, wenn der Benutzer zunächst für die Anwendung den Zugriff verweigerte), und stellt wieder eine valide URL her. Die Methode setAccessToken() ruft die entsprechende Methode in der Klasse OAuthHelper, und übergibt das aktuelle Twitter-Objekt. Schließlich blendet die makeToast()-Methode eine einfache Nachricht für den Benutzer ein. Auf sie greifen die HomeListActivity als auch die AuthorizationActivity zu.
Die HomeListActivity
Die primäre Aktivität innerhalb der Potta Anwendung ist die HomeListActivity. Diese Aktivität überprüft, ob der Benutzer autorisiert ist, und zeigt dann seine Home-Timeline an. Ist der Benutzer nicht angemeldet, wird die AuthorizationActivity über einen Intent initiiert. Das Layout der HomeListActivity fügen Sie im Verzeichnis res/layout als Datei home_list.xml hinzu. Den nötigen Code zeigt Listing 3.
<?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">
<ListView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:id="@id/android:list" />
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:id="@id/android:empty"
android:text="@string/no_tweets"
android:gravity="center_vertical|center_horizontal"
android:padding="10sp" />
</RelativeLayout>
Das Layout enthält zwei Elemente: eine ListView, mit dem die Tweets angezeigt werden; und eine TextView, die dann angezeigt wird, wenn ListView kein Element enthält. Der String @string/no_tweets ist in der Datei res/values/strings.xml enthalten, wie in Listing 4 gezeigt.
<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">Potta</string> <string name="home_list_title">Potta</string> <string name="no_tweets">No tweets.</string> <string name="authorization_title">Authorization</string> </resources>
Die Klasse HomeListActivity erstellen Sie aufgrund des oben definierten Layouts dann wie in Listing 5 gezeigt.
package app.potta.activities;
import java.util.ArrayList;
import twitter4j.ResponseList;
import twitter4j.Status;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import app.potta.PottaApplication;
import app.potta.R;
import android.app.ListActivity;
import android.content.Intent;
import android.os.Bundle;
import android.widget.ArrayAdapter;
public class HomeListActivity extends ListActivity {
private PottaApplication app;
private Twitter twitter;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
app = (PottaApplication)getApplication();
setContentView(R.layout.home_list);
}
@Override
protected void onResume() {
super.onResume();
twitter = app.getTwitter();
if (!app.getOAuthHelper().isAuthorized()) {
loadAuthorizationActivity();
} else {
loadHomeTimelineIfNotLoaded();
}
}
private void loadAuthorizationActivity() {
Intent intent = new Intent(this, AuthorizationActivity.class);
startActivity(intent);
}
private void loadHomeTimelineIfNotLoaded() {
if (null == getListAdapter()) {
loadHomeTimeline();
} else {
app.makeToast("Sie sehen bereits die aktuellste Zeitleiste.")
.show();
}
}
private void loadHomeTimeline() {
try {
ResponseList<Status> homeTimeline = twitter.getHomeTimeline();
ArrayList<String> tweets = new ArrayList<String>();
for (Status status : homeTimeline) {
tweets.add(status.getText());
}
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,
android.R.layout.simple_list_item_1, tweets);
setListAdapter(adapter);
} catch (TwitterException e) {
//TODO Clear "dirty" access tokens, and prompt user to authorize the
application again.
throw new RuntimeException("Kann Home-Timeline nicht laden.", e);
}
}
}
Die Klasse erweitert die ListActivity, um die Home-Timeline des Benutzers in Form einer Liste anzuzeigen. Zuerst überprüfen wir, ob die PottaApplication– und Twitter-Objekte erreichbar sind, die von den verschiedenen Methoden in dieser Klasse benutzt werden. Die onResume()-Methode wird beim Start der Aktivität und jedes Mal, wenn der Benutzer diese wieder ansieht, aufgerufen. Dadurch stellen wir sicher, dass die App immer das aktuellste Twitter-Objekt anzeigt. Zudem prüft die Methode, ob der Benutzer die Anwendung autorisiert hat.
Die Verzweigung ist ziemlich trivial: Wenn der Benutzer die Anwendung nicht autorisierte, wird ein neuer Intent generiert, der die AuthorizationActivity startet, sonst lädt die App die Timeline. Die dazwischengeschaltete Methode loadHomeTimelineIfNotLoaded() wird verwendet, um das Laden der Zeitleiste zu verhindern, wenn der Benutzer bereits den aktuellsten Stand sieht.
Twitter4J bietet Ihnen eine ganze Reihe von Methoden an und gibt in den meisten Fällen eine ResponseList zurück, in diesem Beispiel eine ResponseList von Status-Objekten. Diese Objekte lassen sich über einen ArrayAdapter einem Array hinzufügen. Das ist der einfachste Weg, um eine Liste anzuzeigen, aber Sie können Ihre eigene Methode erstellen, indem Sie die ArrayAdapter-Klasse ergänzen, um zum Beispiel Avatare oder andere Einzelheiten, wie Termine und Standort anzuzeigen. Eine andere Erweiterung wäre dann noch für den Fall nützlich, wenn die App die Zeitleiste nicht laden kann, weil Twitter nicht erreichbar ist oder der Benutzer nicht auf die Anwendung zugreifen kann.
AuthorizationActivity
In der Klasse AuthorizationActivity richten wir eine benutzerdefinierte WebView und einen WebViewClient ein, der dann als eigenständiger integrierter Web-Browser funktioniert. Dies ist eine der eleganten Komponenten, die das Android-SDK bereitstellt. Damit können Sie den Typ Ihrer Twitter-Anwendung auf Browser setzen. Die in Listing 6 gezeigte Datei authorization.xml legen Sie zusammen mit home_list.xml im Verzeichnis res/layout ab.
<?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">
<WebView
android:id="@+id/web_view"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
</RelativeLayout>
Die Datei definiert eine einfache WebView, die dann mit ihrer eigenen web_view-Kennung in der Klasse AuthorizationActivity referenziert wird (Listing 7).
package app.potta.activities;
import app.potta.R;
import app.potta.PottaApplication;
import android.app.Activity;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.webkit.WebView;
import android.webkit.WebViewClient;
public class AuthorizationActivity extends Activity {
private PottaApplication app;
private WebView webView;
private WebViewClient webViewClient = new WebViewClient() {
@Override
public void onLoadResource(WebView view, String url) {
Uri uri = Uri.parse(url);
if (uri.getHost().equals("potta.com")) {
String authToken = uri.getQueryParameter("oauth_token");
if (authToken != null) {
webView.setVisibility(View.INVISIBLE);
app.setAccessToken();
finish();
} else {
app.makeToast("Sie müssen angemeldet sein, um diese Anwendung zu nutzen.
Versuchen Sie es bitte noch einmal.").show();
loadAuthorizationUrl();
}
} else {
super.onLoadResource(view, url);
}
}
};
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
app = (PottaApplication)getApplication();
setContentView(R.layout.authorization);
webView = (WebView)findViewById(R.id.web_view);
webView.setWebViewClient(webViewClient);
}
@Override
protected void onResume() {
super.onResume();
loadAuthorizationUrl();
}
private void loadAuthorizationUrl() {
String authUrl = app.getAuthorizationUrl();
webView.loadUrl(authUrl);
}
}
Eine der wichtigsten Komponenten in dieser Aktivität ist der WebViewClient. Wir überschreiben seine onLoadResource()-Methode, die jedes Mal aufgerufen wird, wenn eine neue Web-Ressource angefordert wird und verzweigen je nachdem, ob unsere URI den Hostnamen potta.com enthält. Abbildung 3 zeigt, wie dies auf Ihrem Handy aussieht.
Wenn der Benutzer den Zugriff auf seinen Konto genehmigt, leitet ihn Twitter mit dem oauth_token– Parameter zusammen zur Callback-URL der Anwendung zurück. Diese verlangt ein Access Token und ein Token Secret und beendet die Aktivität über die finish()-Methode. Der Benutzer sieht dann wieder die HomeListActivity, aber diesmal mit der gewünschten Home-Timeline. Bei einem Fehler wird einfach die loadAuthorizationUrl()-Methode aufgerufen, die die WebView neu lädt.
AndroidManifest.xml
Bevor Sie die App endlich ausführen können, müssen Sie allerdings noch die Datei AndroidManifest.xml konfigurieren. Sie enthält all die Referenzen zu den Ressourcen Ihrer Anwendung, wie Aktivitäten und Intents. In dieser Datei legen Sie auch die niedrigste SDK-Version für Android fest sowie zusätzlichen Berechtigungen, die für Ihre Anwendung erforderlich sind (zum Beispiel den Internetzugang). Listing 8 zeigt den Inhalt der Datei.
<?xml version="1.0" encoding="utf-8"?>
<manifest
xmlns:android="http://schemas.android.com/apk/res/android"
package="app.potta"
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"
android:name=".PottaApplication">
<activity
android:name=".activities.HomeListActivity"
android:label="@string/home_list_title">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity
android:name=".activities.AuthorizationActivity"
android:label="@string/authorization_title" />
</application>
</manifest>
Besonders wichtig ist der Wert in android:name=".PottaApplication" innerhalb des <application>-Tags. Er teilt dem Compiler mit, dass es sich hier um eine PottaApplication und nicht um eine Standard-Anwendung handelt. Überprüfen Sie auch, ob HomeListActivity und AuthorizationActivity referenziert sind, sonst erhalten Sie beim Start der App einen Compiler-Fehler.
Das war’s
Wenn alles richtig funktioniert, sollten Sie nun in der Lage sein, die Anwendung auszuführen und Sie sehen Twitters Anmeldefenster. Genehmigen Sie den Zugriff auf Ihr Konto und schon erscheint Ihre Home-Timeline. Herzlichen Glückwunsch, Sie sind authentifiziert und bereit, Ihre nächste Twitter-Anwendung zu bauen!
Infos
- Github: http://github.com/markhawker/Potta
- Android Developer’s Guide: http://developer.android.com/guide/
- Android Statistiken: http://developer.android.com/resources/dashboard/platform-versions.html
- Twitter4J: http://twitter4j.org/
- Twitter Entwickler: http://dev.twitter.com/