Erstellen eines Twitter-Clients für Android: Tweeten, Retweeten und Antworten

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

In dieser Serie erstellen wir einen Twitter-Client für die Android-Plattform unter Verwendung der Twitter4J-Bibliothek. Dieses Tutorial konzentriert sich auf das Implementieren von Tweeten, Retweeten und Antworten auf Tweets. Wir werden eine neue Aktivität zum Twittern und Antworten erstellen, mit Retweet- und Antwortschaltflächen, die für jeden Tweet in der Home-Timeline des Benutzers implementiert sind.

Auch in dieser Serie erhältlich:

Erstellen eines Twitter-Clients für Android: Setup & Übersicht
Erstellen eines Twitter-Clients für Android: Erstellen der Benutzeroberfläche
Erstellen eines Twitter-Clients für Android: Erstellen einer Timeline-Datenbank
Erstellen eines Twitter-Clients für Android: Abrufen von Updates mithilfe eines Dienstes
Erstellen eines Twitter-Clients für Android: Tweeten, Retweeten und Antworten

In den ersten vier Tutorials haben wir:

Registrierte die App bei Twitter.
Importierte die Twitter4J-Bibliothek.
Behandelte Benutzerauthentifizierung.
Die Benutzeroberfläche wurde mithilfe von XML-Ressourcen erstellt.
Erstellt eine SQLite-Datenbank zum Speichern der Tweets für die Home-Timeline des Benutzers.
Ordnete die Daten mithilfe eines Adapters den sichtbaren Ansichten zu.
Abrufen neuer Updates in regelmäßigen Abständen mithilfe eines Dienstes und einer Übertragung.

Schritt 1: Erstellen Sie eine Tweet-Aktivität

Unsere App wird zusätzlich zum Hauptbildschirm der Timeline eine zweite Aktivität haben. Diese neue Aktivität dient zum Senden von Tweets. Darin kann der Benutzer Text eingeben, um einen Tweet von seinem Twitter-Konto aus zu senden. Der Benutzer kann die Tweet-Aktivität auf zwei Arten eingeben: durch Drücken der Tweet-Taste auf dem Hauptbildschirm der App oder durch Drücken einer Antworttaste in der Zeitleiste.

Wenn der Benutzer die Tweet-Taste drückt, wird ihm ein leeres Textfeld zur Eingabe seines Tweets angezeigt. Zum Senden wird eine Schaltfläche zum Senden verwendet.

Wenn der Benutzer die Antwortschaltfläche innerhalb eines Timeline-Tweets drückt, wird ihm auch das Textfeld angezeigt, aber der Benutzername für die Antwort wird bereits in das Feld eingetragen. Die Antwort muss auch mit der ID des Tweets gesendet werden, auf den geantwortet wird, was wir ebenfalls implementieren werden.

Erstellen Sie eine neue Klasse in Ihrem Android-Projekt und nennen Sie sie "NiceTweet", damit sie mit de Namen übereinstimmt, den Sie im ersten Lernprogramm in Ihre Manifest-Datei aufgenommen haben. Ändern Sie die Klassendeklaration wie folgt:

1
2	public class NiceTweet extends Activity implements OnClickListener {

Sie benötigen die folgenden Android-Importe:

 
import android.app.Activity; 
import android.content.SharedPreferences; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.View; 
import android.view.View.OnClickListener; 
import android.widget.Button; 
import android.widget.EditText; 
import android.widget.LinearLayout;

Plus diese Twitter4J-Importe:

 
import twitter4j.StatusUpdate; 
import twitter4j.Twitter; 
import twitter4j.TwitterException; 
import twitter4j.TwitterFactory; 
import twitter4j.conf.Configuration; 
import twitter4j.conf.ConfigurationBuilder;

Nehmen Sie die folgenden Instanzvariablen in Ihre Klassendeklaration auf:

 
	/**shared preferences for user twitter details*/ 
private SharedPreferences tweetPrefs; 
	/**twitter object**/ 
private Twitter tweetTwitter; 
 
	/**twitter key*/ 
public final static String TWIT_KEY = "your key"; 
	/**twitter secret*/ 
public final static String TWIT_SECRET = "your secret"; 
 
	/**the update ID for this tweet if it is a reply*/ 
private long tweetID = 0; 
	/**the username for the tweet if it is a reply*/ 
private String tweetName = "";

Wir werden die Variablen "Einstellungen", "Twitter", "Schlüssel" und "Geheime" verwenden, um über das Benutzerkonto auf die Twitter4J-Methoden zum Twittern zuzugreifen. Ändern Sie den Schlüssel und das Geheimnis nach Ihren Wünschen. Die letzten beiden Variablen sind für Antworten. Wenn der Benutzer die Antwortschaltfläche innerhalb eines Tweets drückt, geben wir die ID des Tweets, auf den geantwortet wird, zusammen mit dem Twitter-Bildschirmnamen des Kontos weiter, auf das wir antworten. Wir werden diese in den beiden Instanzvariablen speichern.

Implementieren wir die Aktivitätserstellungsmethode:

 
/* 
 * onCreate called when activity is created 
 */ 
@Override 
public void onCreate(Bundle savedInstanceState) { 
	super.onCreate(savedInstanceState); 
		//set tweet layout 
	setContentView(R.layout.tweet);   
}

Alles, was wir hier tun, ist das Tweet-Layout festzulegen, das wir zuvor in XML definiert haben. Implementieren Sie als Nächstes die Wiederaufnahme-Methode, die aufgerufen wird, wenn die Aktivität für den Benutzer sichtbar wird:

 
/* 
 * Call setup method when this activity starts 
 */ 
@Override 
public void onResume() { 
	super.onResume(); 
		//call helper method 
	setupTweet(); 
}

Wir werden die angegebene Hilfsmethode bereitstellen, um die Aktivität für die Benutzerinteraktion einzurichten.

Schritt 2: Bereiten Sie sich auf Tweet vor

Fügen Sie Ihrer Klasse die Methode "setupTweet" wie folgt hinzu:

 
/** 
 * Method called whenever this Activity starts 
 * - get ready to tweet 
 * Sets up twitter and onClick listeners 
 * - also sets up for replies 
 */ 
private void setupTweet() { 
	//prepare to tweet 
 
}

Innerhalb dieser Methode müssen wir die Klasse so vorbereiten, dass sowohl normale Tweets als auch Antworten gesendet werden. Verwenden wir zunächst die freigegebenen Einstellungen, um unser Twitter-Objekt zu instanziieren:

 
	//get preferences for user twitter details 
tweetPrefs = getSharedPreferences("TwitNicePrefs", 0); 
         
       	//get user token and secret for authentication 
String userToken = tweetPrefs.getString("user_token", null); 
String userSecret = tweetPrefs.getString("user_secret", null); 
 
	//create a new twitter configuration usign user details 
Configuration twitConf = new ConfigurationBuilder() 
	.setOAuthConsumerKey(TWIT_KEY) 
	.setOAuthConsumerSecret(TWIT_SECRET) 
	.setOAuthAccessToken(userToken) 
	.setOAuthAccessTokenSecret(userSecret) 
	.build(); 
 
	//create a twitter instance 
tweetTwitter = new TwitterFactory(twitConf).getInstance();

Hier erstellen wir ein Twitter-Objekt unter Verwendung der Authentifizierungsinformationen des Benutzers zusammen mit dem Entwicklerschlüssel und dem Geheimnis für die Anwendung. Wenn wir Benutzer zu dieser Aktivitätsklasse führen, geben wir die ID und den Benutzernamen weiter, wenn auf einen Tweet geantwortet wird. Wir bekommen diese aus der Absicht:

1
2	//get any data passed to this intent for a reply
3	Bundle extras = getIntent().getExtras();

Wenn es sich bei dem Tweet eher um ein gewöhnliches Update als um eine Antwort handelt, gibt es keine Extras. Wenn es Extras gibt, wissen wir, dass der Tweet eine Antwort ist:

 
if(extras !=null) 
{ 
		//get the ID of the tweet we are replying to 
	tweetID = extras.getLong("tweetID"); 
		//get the user screen name for the tweet we are replying to 
	tweetName = extras.getString("tweetUser"); 
 
		//use the passed information 
 
}

Hier rufen wir die ID und den Bildschirmnamen ab, auf die der Tweet antworten soll. Als nächstes verwenden wir diese Informationen, um den Benutzernamen zum Textfeld hinzuzufügen, das sich noch in der "if" -Anweisung befindet:

 
	//get a reference to the text field for tweeting 
EditText theReply = (EditText)findViewById(R.id.tweettext); 
	//start the tweet text for the reply @username 
theReply.setText("@"+tweetName+" "); 
	//set the cursor to the end of the text for entry 
theReply.setSelection(theReply.getText().length());

Wir setzen den Benutzernamen als ersten Teil des Tweet-Textes und platzieren den Cursor am Ende, damit der Benutzer seinen Antworttext sofort eingeben kann.

Als nächstes kümmern wir uns um Fälle, in denen der Tweet keine Antwort ist:

 
else  
{ 
    	EditText theReply = (EditText)findViewById(R.id.tweettext); 
    	theReply.setText(""); 
}

Hier setzen wir den Text einfach auf einen leeren String, wieder unter Verwendung der ID, die wir dem Textfeld im Layout-XML gegeben haben. Jetzt können wir die "setupTweet" -Methode beenden, indem wir Klick-Listener für die Schaltfläche "Senden" und die Schaltfläche "Home" hinzufügen, um zum Hauptbildschirm der Zeitleiste zurückzukehren:

 
	//set up listener for choosing home button to go to timeline 
LinearLayout tweetClicker = (LinearLayout)findViewById(R.id.homebtn); 
tweetClicker.setOnClickListener(this); 
         
	//set up listener for send tweet button 
Button tweetButton = (Button)findViewById(R.id.dotweet); 
tweetButton.setOnClickListener(this);

Wir verwenden wieder die ID-Werte, die wir in unseren Layoutdateien angegeben haben.

Schritt 3: Klicks erkennen

Denken Sie daran, dass die Tweet-Aktivität eine Schaltfläche zum Zurückkehren der Benutzer zur Home-Timeline sowie die Schaltfläche zum Senden des Tweets enthalten wird. Fügen wir nun die "onClick" -Methode hinzu, um Benutzer zu behandeln, die auf diese Schaltflächen klicken:

 
/** 
 * Listener method for button clicks 
 * - for home button and send tweet button 
 */ 
public void onClick(View v) { 
	//handle home and send button clicks 
 
}

Holen Sie sich zuerst einen Verweis auf das Textfeld:

1
2	EditText tweetTxt = (EditText)findViewById(R.id.tweettext);

Jetzt müssen wir mithilfe von switch- und case-Anweisungen herausfinden, auf welche Schaltfläche geklickt wurde:

 
	//find out which view has been clicked 
switch(v.getId()) { 
case R.id.dotweet: 
	//send tweet 
	 
	break; 
case R.id.homebtn: 
	//go to the home timeline 
 
	break; 
default: 
	break; 
}

Implementieren Sie in der case-Anweisung "dotweet" vor der break-Anweisung das Senden eines Tweets wie folgt:

 
String toTweet = tweetTxt.getText().toString(); 
try { 
		//handle replies 
	if(tweetName.length()>0) 
		tweetTwitter.updateStatus(new StatusUpdate(toTweet).inReplyToStatusId(tweetID)); 
		 
		//handle normal tweets 
	else  
		tweetTwitter.updateStatus(toTweet); 
			 
		//reset the edit text 
	tweetTxt.setText(""); 
} 
catch(TwitterException te) { Log.e("NiceTweet", te.getMessage()); }

Hier prüfen wir, ob der Tweet eine Antwort ist oder nicht. Die "if" -Anweisung wird ausgeführt, wenn der Tweet eine Antwort ist, einschließlich des Textes aus dem Textfeld und der ID der Statusaktualisierung, auf die wir antworten. Die Anweisung "else" sorgt für das Senden gewöhnlicher Tweets, in denen nur der Text als Parameter übergeben wird. Die Try-and-Catch-Blöcke sind erforderlich, da wir versuchen, über das Netzwerk eine Verbindung zu Twitter herzustellen. Nach dem Senden des Tweets, unabhängig davon, ob es sich um eine Antwort handelt oder nicht, setzen wir das Textfeld zur Vorbereitung auf das nächste Tweet-Update wieder auf leer.

Setzen Sie für die case-Anweisung "homebtn" einfach das Textfeld auf einen leeren String:

1
2	tweetTxt.setText("");

Beenden Sie die Aktivität nach der switch-Anweisung, die sich jedoch noch in der "onClick" -Methode befindet, so, dass sie zur Home-Timeline zurückkehrt:

1
2	finish();

Unabhängig davon, ob es sich bei dem Tweet um eine Antwort oder ein gewöhnliches Update handelt, kehren wir beim Senden des Benutzers sofort zum Hauptbildschirm zurück. Dies geschieht auch, wenn er die Home-Taste drückt. Die Finish-Anweisung wird in allen drei Fällen ausgeführt.

Schritt 4: Modellieren Sie Tweet-Daten für Retweets und Antworten

Um das Retweeten und Antworten zu implementieren, müssen wir die Tweet-ID und den Benutzernamen in den Retweet- und Antwortschaltflächen für jeden Tweet in der Timeline speichern. Durch Speichern dieser Daten in der Schaltfläche Ansichten für Retweet und Antwort können wir erkennen, welcher Tweet retweetet oder beantwortet wird, wenn der Benutzer eine Schaltfläche drückt.

Da die Informationen, die wir speichern müssen, eine Zahl und Text enthalten, erstellen wir eine Klasse, um sie zu modellieren. Erstellen Sie eine neue Klasse in Ihrem Projekt und nennen Sie sie "StatusData". Ihre neue Klasse sollte wie folgt beginnen:

1
2	public class StatusData {

Fügen Sie innerhalb der Klasse Instanzvariablen für die Tweet-ID und den Benutzernamen hinzu:

 
/**tweet ID*/ 
private long tweetID; 
 
/**user screen name of tweeter*/ 
private String tweetUser;

Die ID wird als Long modelliert, wobei der Bildschirmname eine Textzeichenfolge ist. Fügen Sie der Klasse eine Konstruktormethode hinzu:

 
/** 
 * Constructor receives ID and user name 
 * @param ID 
 * @param screenName 
 */ 
public StatusData(long ID, String screenName) { 
		//instantiate variables 
	tweetID=ID; 
	tweetUser=screenName; 
}

Die Methode instanziiert einfach die beiden Variablen. Fügen Sie als Nächstes eine öffentliche Methode hinzu, damit wir die Tweet-ID an anderer Stelle abrufen können:

 
/** 
 * Get the ID of the tweet 
 * @return tweetID as a long 
 */ 
public long getID() {return tweetID;}

Fügen Sie dann eine Methode hinzu, um den Bildschirmnamen zurückzugeben:

 
/** 
 * Get the user screen name for the tweet 
 * @return tweetUser as a String 
 */ 
public String getUser() {return tweetUser;}

Mit diesen Methoden können wir diese Informationen abrufen, wenn Benutzer auf die Schaltfläche "Retweet" oder "Antworten" für einen bestimmten Tweet klicken.

Schritt 5: Erweitern Sie die Bindung für Retweets und Antworten

Jetzt müssen wir den Code in der von uns erstellten Adapterklasse ("UpdateAdapter") erweitern. Bei der Methode "bindView" haben wir die Zuordnung von Daten zu den Ansichten der Benutzeroberfläche angepasst. Jetzt werden wir die weitere Verarbeitung hinzufügen, um die Tweet-Daten in jeden Retweet- und Antwort-Button aufzunehmen. Beginnen Sie vor dem Ende Ihrer "bindView" -Methode wie folgt:

 
	//get the status ID 
long statusID = cursor.getLong(cursor.getColumnIndex(BaseColumns._ID)); 
	//get the user name 
String statusName = cursor.getString(cursor.getColumnIndex("user_screen"));

Denken Sie daran, dass der Methode "bindView" ein Cursor-Objekt zum Durchlaufen der Daten übergeben wird. Hier verwenden wir den Cursor, um den langen ID-Wert und den String-Benutzernamen für den aktuellen Tweet abzurufen. Sie benötigen den folgenden zusätzlichen Import:

1
2	import android.provider.BaseColumns;

Jetzt instanziieren wir ein Objekt unserer neuen StatusData-Klasse und übergeben die Tweet-Daten an die Konstruktormethode:

1
2	//create a StatusData object to store these
3	StatusData tweetData = new StatusData(statusID, statusName);

Das StatusData-Objekt enthält alles, was zum Senden eines Retweets oder einer Antwort auf den betreffenden Tweet erforderlich ist. Wir werden nun einen Verweis auf dieses Objekt in den Retweet- und Antwortschaltflächen für den Tweet anhängen, damit wir nach Benutzerklicks auf die Informationen zugreifen können. Wir verwenden die "setTag" -Methode:

1
2	//set the status data object as tag for both retweet and reply buttons in this view
3	row.findViewById(R.id.retweet).setTag(tweetData);
4	row.findViewById(R.id.reply).setTag(tweetData);

Die Methode "bindView" empfängt auch einen Parameter, der die Zeilenansicht darstellt, in der der Tweet angezeigt werden soll. Wenn Sie auf die aktualisierte XML-Layoutdatei zurückblicken, werden Sie feststellen, dass diese beiden ID-Werte für die Schaltflächen enthalten sind. Wir setzen das Tag in jeder Schaltfläche so, dass es das StatusData-Objekt widerspiegelt, das die ID und den Benutzernamen für den angezeigten Tweet enthält. Jetzt müssen wir Tastenklicks für diese einrichten:

1
2	//setup onclick listeners for the retweet and reply buttons
3	row.findViewById(R.id.retweet).setOnClickListener(tweetListener);
4	row.findViewById(R.id.reply).setOnClickListener(tweetListener);

Hier geben wir einen Klick-Listener an, um Schaltflächenklicks zu verarbeiten. Innerhalb der Listener-Methode können wir die StatusData-Objekte aller angeklickten Retweet- und Antwortschaltflächen abrufen. Wir werden Benutzern auch erlauben, auf den Benutzernamen für einen Tweet zu klicken, um das Benutzerprofil im Webbrowser zu öffnen. Fügen Sie dieser Ansicht auch hier einen Klick-Listener hinzu:

1
2	//setup onclick for the user screen name within the tweet
3	row.findViewById(R.id.userScreen).setOnClickListener(tweetListener);

Auf diese Weise können wir eine Verknüpfung zur Twitter-Weboberfläche herstellen, sodass Benutzer auf Funktionen zugreifen können, die wir nicht in der App selbst bereitgestellt haben.

Schritt 6: Klicken auf Schaltfläche und Benutzername verarbeiten

Erstellen Sie in Ihrer UpdateAdapter-Klasse einen "onClickListener", um Klicks zu verarbeiten, und verwenden Sie den Namen "tweetListener", um den Angaben in der Methode "bindView" zu entsprechen:

 
/** 
 * tweetListener handles clicks of reply and retweet buttons 
 * - also handles clicking the user name within a tweet 
 */ 
private OnClickListener tweetListener = new OnClickListener() { 
	//onClick method 
	public void onClick(View v) { 
 
	} 
};

Fügen Sie der Adapterklasse die folgenden zusätzlichen Importe hinzu:

 
import android.view.View.OnClickListener; 
import android.content.Intent; 
import android.content.SharedPreferences; 
import android.widget.Toast; 
import android.net.Uri; 
import twitter4j.Twitter; 
import twitter4j.TwitterException; 
import twitter4j.TwitterFactory; 
import twitter4j.conf.Configuration; 
import twitter4j.conf.ConfigurationBuilder;

Innerhalb der "onClick" -Methode implementieren wir Klicks auf beide Schaltflächen plus den Benutzernamen. Fügen Sie eine switch-Anweisung hinzu, um festzustellen, auf welche geklickt wurde:

 
//which view was clicked 
switch(v.getId()) { 
		//reply button pressed 
	case R.id.reply: 
		//implement reply 
 
		break; 
		//retweet button pressed 
	case R.id.retweet: 
		//implement retweet 
 
		break; 
		//user has pressed tweet user name 
	case R.id.userScreen: 
		//implement visiting user profile 
 
		break; 
	default: 
		break; 
}

In der Antwortfallanweisung starten wir die Tweet-Aktivitätsklasse und übergeben die Antwortdaten, damit die Antwort-ID und der Benutzername beim Senden des Tweets enthalten sein können:

 
	//create an intent for sending a new tweet 
Intent replyIntent = new Intent(v.getContext(), NiceTweet.class); 
	//get the data from the tag within the button view 
StatusData theData = (StatusData)v.getTag(); 
	//pass the status ID 
replyIntent.putExtra("tweetID", theData.getID()); 
	//pass the user name 
replyIntent.putExtra("tweetUser", theData.getUser()); 
	//go to the tweet screen 
v.getContext().startActivity(replyIntent);

Beachten Sie, dass wir das Tag für die gedrückte Ansicht abrufen und es als StatusData-Objekt umwandeln. Anschließend rufen wir die öffentlichen Methoden auf, die wir in der StatusData-Klasse bereitgestellt haben, um die Tweet-ID und den Bildschirmnamen des Benutzers zurückzugeben. Wir übergeben diese als Extras an die Tweet-Aktivität und starten dann die Aktivität. An diesem Punkt wird der Benutzer zum Tweet-Bildschirm weitergeleitet, wo die Antwortdaten verwendet werden, um die Antwort auf den richtigen Tweet zu implementieren.

In der Retweet-Case-Anweisung werden wir den relevanten Tweet direkt mit den Twitter4J-Methoden retweeten. Instanziieren Sie zuerst ein Twitter-Objekt mithilfe der freigegebenen Einstellungen sowie Ihres Entwicklerschlüssels und des Geheimnisses für die App:

 
	//get context 
Context appCont = v.getContext(); 
	//get preferences for user access 
SharedPreferences tweetPrefs = appCont.getSharedPreferences("TwitNicePrefs", 0); 
String userToken = tweetPrefs.getString("user_token", null); 
String userSecret = tweetPrefs.getString("user_secret", null); 
 
	//create new Twitter configuration 
Configuration twitConf = new ConfigurationBuilder() 
	.setOAuthConsumerKey(TWIT_KEY) 
	.setOAuthConsumerSecret(TWIT_SECRET) 
	.setOAuthAccessToken(userToken) 
	.setOAuthAccessTokenSecret(userSecret) 
	.build(); 
 
	//create Twitter instance for retweeting 
Twitter retweetTwitter = new TwitterFactory(twitConf).getInstance();

Dies ist die gleiche Technik, mit der wir zuvor die Twitter-Klasse instanziiert haben. Wir können jetzt das Twitter-Objekt verwenden, um den Retweet zu senden. Zuerst müssen wir das StatusData-Objekt von der Schaltfläche abrufen, auf die geklickt wurde:

1
2	//get tweet data from view tag
3	StatusData tweetData = (StatusData)v.getTag();

Jetzt können wir versuchen, das Update in einem Try-Block erneut zu twittern:

 
try  
{ 
		//retweet, passing the status ID from the tag 
	retweetTwitter.retweetStatus(tweetData.getID()); 
 
} 
catch(TwitterException te) {Log.e(LOG_TAG, te.getMessage());}

Alles, was das Twitter-Objekt zum Senden eines Retweets benötigt, ist die ID des ursprünglichen Tweets. Lassen Sie uns dem Benutzer jedoch bestätigen, dass sein Retweet gesendet wurde, immer noch im Try-Block:

 
	//confirm to use 
CharSequence text = "Retweeted!"; 
int duration = Toast.LENGTH_SHORT; 
Toast toast = Toast.makeText(appCont, text, duration); 
toast.show();

Sie können die Nachricht natürlich ändern, wenn Sie möchten. So sieht es aus:

Erlauben Sie dem Benutzer nun, eine Twitter-Profilseite im Webbrowser zu besuchen, indem Sie auf den Bildschirmnamen im aktuellen Tweet in der case-Anweisung "userScreen" klicken:

 
	//get the user screen name 
TextView tv = (TextView)v.findViewById(R.id.userScreen); 
String userScreenName = tv.getText().toString(); 
	//open the user's profile page in the browser 
Intent browserIntent = new Intent(Intent.ACTION_VIEW,  
	Uri.parse("https://twitter.com/"+userScreenName)); 
v.getContext().startActivity(browserIntent);

Hier rufen wir den Benutzernamen als Textzeichenfolge aus der Ansicht selbst ab, die den Bildschirmnamen ohnehin als Zeichenfolge anzeigt. Wir bauen dies in eine Twitter-Profilseitenadresse ein, analysieren sie als URI und weisen den Browser an, sie zu öffnen.

Schritt 7: Implementieren Sie den Umzug von zu Hause nach Tweet

Denken Sie daran, dass in unserer Haupt-App-Aktivität eine Schaltfläche angezeigt wird, mit der Benutzer direkt zum Tweet-Bildschirm gelangen. Lassen Sie uns das jetzt implementieren. Fügen Sie in Ihrer Hauptaktivitätsklasse Folgendes in Ihre "setupTimeline" -Methode ein, nachdem Sie die Hauptinhaltsansicht festgelegt haben:

1
2	//setup onclick listener for tweet button
3	LinearLayout tweetClicker = (LinearLayout)findViewById(R.id.tweetbtn);
4	tweetClicker.setOnClickListener(this);

Die ID der Tweet-Schaltfläche entspricht der ID, die wir in der XML-Layoutdatei der Hauptzeitleiste enthalten haben. Die Hauptaktivitätsklasse wird Klicks auf die Tweet-Schaltfläche verarbeiten. Wenn Sie sich Ihre "onClick" -Methode in der Hauptaktivität ansehen ("TwitNiceActivity", wenn Sie den Namen im ersten Lernprogramm verwendet haben), sollte eine switch-Anweisung mit einer case-Anweisung für die Schaltfläche "signin" angezeigt werden. Fügen Sie eine zweite case-Anweisung für die Tweet-Schaltfläche wie folgt hinzu (vor der Standardanweisung):

 
	//user has pressed tweet button 
case R.id.tweetbtn: 
		//launch tweet activity 
	startActivity(new Intent(this, NiceTweet.class)); 
	break;

Hier starten wir einfach die Tweet-Aktivität. Wir müssen keine Informationen an die Aktivität weitergeben, da der Benutzer sie in diesem Fall einfach startet, um einen normalen Tweet zu senden.

Das ist es!

Das ist unsere Twitter App komplett! Führen Sie die App auf einem Emulator oder Gerät aus, um zu sehen, ob sie funktioniert. Beim ersten Start müssen Sie natürlich zustimmen, dass die App Ihr Twitter-Konto verwendet. Sie können optional ein separates Twitter-Konto erstellen, mit dem Sie die App testen können, anstatt Ihr normales Konto zu verwenden. Nach der Autorisierung sollte Ihnen die Home-Timeline angezeigt werden, die die neuesten Tweets der von Ihnen verfolgten Konten darstellt. Testen Sie das Tweeten, Retweeten und Antworten und stellen Sie sicher, dass Ihre Zeitleiste in dem von Ihnen gewählten Intervall automatisch aktualisiert wird.

Erweiterte Themen

In dieser Tutorial-Serie haben wir einen einfachen Twitter-Client für Android erstellt. Es gibt viele Möglichkeiten, die App zu verbessern und zu vebessern, z. B. die Möglichkeit, Direktnachrichten oder Benutzerprofile in der App anzuzeigen, anstatt den Webbrowser verwenden zu müssen. Sie können auch Erwähnungen von Benutzern in Tweets anklickbar machen (d. H. Eine beliebige Textzeichenfolge mit vorangestelltem "@" mit der Profilseite für diesen Benutzer verknüpfen). Ein ähnlicher Prozess würde es Ihnen ermöglichen, Hashtags zu unterstützen. Fortgeschrittenere Twitter-Clients zeigen bei der Auswahl eines einzelnen Tweets auch Konversationen an und zeigen die Antworten in chronologischer Reihenfolge an.

In Bezug auf die Anwendungsimplementierung gibt es auch Verbesserungen, die Sie in Betracht ziehen könnten. Wenn der Benutzer beispielsweise über eine geringe Konnektivität verfügt, können Sie das Herunterladen der Profilbilder als Hintergrundprozess implementieren. Sie können auch eine Form des Image-Caching implementieren, um die Effizienz zu maximieren. Anstatt dass die App die ListView automatisch mit neuen Tweets aktualisiert, können Sie oben in der Timeline eine Schaltfläche implementieren, mit der Benutzer die Anzeige steuern können. Die Schaltfläche gibt an, wie viele neue Tweets verfügbar sind. Schließlich können Sie die Effizienz verbessern, indem Sie den Service in einem separaten Thread ausführen.

Danke fürs Lesen

Ich hoffe, Ihnen hat diese Serie beim Erstellen eines Twitter-Clients für die Android-Plattform gefallen! Sie lernen nicht nur, wie Sie Ihre Apps mit Twitter verbinden, sondern haben auch Erfahrung mit der Verwendung einer externen Bibliothek sowie einer Vielzahl von Ressourcen für Android-Plattformen wie Datenbanken, Adapter, Dienste und Broadcasts. Dies sind alles Schlüsselkompetenzen, von denen Ihre zukünftigen Android-Projekte profitieren werden. Der herunterladbare Quellcode enthält zusätzliche Hinweise, die Sie möglicherweise hilfreich finden.