Membuat klien Twitter untuk Android: membuat Timeline Database

Indonesian (Bahasa Indonesia) translation by Dika Budiaji (you can also view the original English article)

Dalam seri ini, kita membuat Twitter klien untuk platform Android menggunakan perpustakaan Twitter4J. Tutorial ini akan membuat database SQLite untuk menyimpan user home timeline. Kami juga akan memetakan data dari database ke view kita buat terakhir kali menggunakan adaptor, sehingga pengguna dapat melihat perkembangan mereka.

Juga tersedia dalam seri ini:

Membuat klien Twitter untuk Android: Setup & Ikhtisar
Membuat klien Twitter untuk Android: membangun antarmuka
Membuat klien Twitter untuk Android: membuat Timeline Database
Membuat klien Twitter untuk Android: mengambil menggunakan Layanan Update
Membuat klien Twitter untuk Android: Tweeting, Retweeting dan membalas

Dalam tutorial pertama dua kami setup proyek di Eclipse, mendaftar aplikasi Twitter, impor file Twitter4J JAR dan membangun user interface. Kami juga menangani persiapan pengguna untuk masuk ke account Twitter dan otorisasi aplikasi untuk mengakses tweets mereka.

Tutorial ini akan membuat database SQLite untuk menyimpan pengguna rumah timeline. Kami juga akan memetakan data dari database ke View yang kita buat terakhir kali menggunakan adaptor, sehingga pengguna dapat melihat perkembangan mereka.

Langkah 1: Buat Database

Mari kita masuk langsung dan membuat database timeline menggunakan SQLite. Membuat kelas baru dalam proyek Anda dengan memilihnya dalam Explorer paket, memilih File, New kemudian Class. Masukkan "NiceDataHelper" sebagai nama kelas. Buka file kelas baru dan extends Deklarasi sebagai berikut:

 
public class NiceDataHelper extends SQLiteOpenHelper

Ini adalah kelas helper database SQLite sistem. Dalam kelas ini, kami akan membuat dan mengelola database untuk home timeline tweet.

Tambahkan statement impor berikut di bagian atas kelas:

 
import android.content.Context; 
import android.database.sqlite.SQLiteDatabase; 
import android.database.sqlite.SQLiteOpenHelper; 
import android.provider.BaseColumns; 
import android.util.Log;

Impor ini adalah untuk dasar database pengolahan dan error logging, ditambah aplikasi Context untuk general reference.

Database akan mengandung sebuah tabel tunggal untuk tweet update. Tabel ini akan termasuk kolom berikut untuk setiap tweet: Twitter ID status; tweet teks; nama layar dari tweeter; waktu tweet dikirim; URL gambar profil tweeter.

Mulailah dengan membuat beberapa konstanta dalam kelas:

 
  /**db version*/ 
private static final int DATABASE_VERSION = 1; 
	/**database name*/ 
private static final String DATABASE_NAME = "home.db"; 
	/**ID column*/ 
private static final String HOME_COL = BaseColumns._ID; 
	/**tweet text*/ 
private static final String UPDATE_COL = "update_text"; 
	/**twitter screen name*/ 
private static final String USER_COL = "user_screen"; 
	/**time tweeted*/ 
private static final String TIME_COL = "update_time"; 
	/**user profile image*/ 
private static final String USER_IMG = "user_img";

Variabel konstan ini mencakup database versi nama, Anda harus mengubah jika Anda ingin meng-upgrade database di masa depan development aplikasi Anda. Variabel ini juga mencakup nama database dan nama kolom. Kelas BaseColumns membantu kita untuk menetapkan kolom ID unik menggunakan akhiran "_id".

Berikutnya membangun SQLite membuat table String untuk tabel home:

 
	/**database creation string*/ 
private static final String DATABASE_CREATE = "CREATE TABLE home (" + HOME_COL +  
	" INTEGER NOT NULL PRIMARY KEY, " + UPDATE_COL + " TEXT, " + USER_COL +  
	" TEXT, " + TIME_COL + " INTEGER, " + USER_IMG + " TEXT);";

Membuat metode konstruktor untuk kelas helper database Anda:

 
/** 
 * Constructor method 
 * @param context 
 */ 
NiceDataHelper(Context context) { 
	super(context, DATABASE_NAME, null, DATABASE_VERSION); 
}

Konstruktor hanya memanggil metode superclass. Selanjutnya tambahkan metode "onCreate" di mana kita akan mengeksekusi pembentukan tabel database:

 
/* 
 * onCreate executes database creation string 
 */ 
@Override 
public void onCreate(SQLiteDatabase db) { 
db.execSQL(DATABASE_CREATE); 
}

Di sini kita adalah hanya mengeksekusi pembuatan database SQL String. Pada akhir metode tabel akan dibuat.

Untuk menyelesaikan menyiapkan database kami, menerapkan metode yang "onUpgrade" jika Anda memutuskan untuk mengubah database dikemudian hari:

 
/* 
 * onUpgrade drops home table and executes creation string 
 */ 
@Override 
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { 
db.execSQL("DROP TABLE IF EXISTS home"); 
db.execSQL("VACUUM"); 
onCreate(db); 
}

Hal ini memungkinkan Anda untuk meng-upgrade database Anda dengan mengubah nomor versi dan pembuatan String, atau salah satu kolom.

Kita sekarang akan menambahkan sebuah metode akhir kelas helper database kami. Metode ini akan kembali nilai-nilai dari diperoleh Twitter status update terbaru dan akan dipanggil dari kelas Service kita buat dalam tutorial selanjutnya. Tambahkan garis metode sebagai berikut:

 
/** 
 * getValues retrieves the database records 
 * - called from TimelineUpdater in TimelineService 
 * - this is a static method that can be called without an instance of the class 
 *  
 * @param status 
 * @return ContentValues result 
 */ 
public static ContentValues getValues(Status status) { 
    	 
		//prepare ContentValues to return 
	ContentValues homeValues = new ContentValues(); 
 
		//get the values 
		 
		//return the values 
	return homeValues; 
}

Dalam metode ini kami akan mengkonversi objek Status lulus ke satu set ContentValues. Status kelas adalah bagian dari perpustakaan Twitter4J, pemodelan satu status update, atau tweet. Ketika aplikasi Servuce mengambil user home timeline, itu akan berlalu setiap pembaruan Status di dalamnya metode "getValues". Metode ini akan mengambil informasi dari tweet yang kita inginkan untuk menyimpan dalam database, yaitu ID, teks, nama user, waktu dan profil URL gambar. Metode akan menempatkan masing-masing dalam satu set ContentValues yang akan kemudian mengembalikan. Service akan kemudian mencoba untuk menulis data dalam ContentValues ke database, memperbarui dengan tweets baru diperoleh.

Kami akan menerapkan sebagian dari proses ini ketika kita membuat Service dalam tutorial berikutnya. Sekarang yang perlu kita lakukan adalah memberikan tubuh metode "getValues". Sebelum baris di mana nilai-nilai kembali, tambahkan berikut:

 
try { 
		//get each value from the table 
	homeValues.put(HOME_COL, status.getId()); 
	homeValues.put(UPDATE_COL, status.getText()); 
	homeValues.put(USER_COL, status.getUser().getScreenName()); 
	homeValues.put(TIME_COL, status.getCreatedAt().getTime()); 
	homeValues.put(USER_IMG, status.getUser().getProfileImageURL().toString()); 
} 
catch(Exception te) { Log.e("NiceDataHelper", te.getMessage()); }

Proses dapat menyebabkan exception, jadi try catch blok diperlukan. Perhatikan bahwa upaya metode untuk mengambil setiap elemen dari Status update bahwa kita dirancang database untuk menyimpan menggunakan metode Twitter4J. Anda akan memerlukan beberapa impor ditambahkan ke kelas:

 
import twitter4j.Status; 
import android.content.ContentValues;

Langkah 2: Buat kelas Adapter

Kita akan menggunakan adaptor kelas untuk memetakan data menciak ke User interface View yang kami buat dalam tutorial terakhir. ListView yang kami buat dalam layout file timeline XML akan menunjukkan menampilkan tweet Baru sebagai mereka menjadi tersedia. Setiap tweet update akan ditampilkan dalam tata letak XML update yang kita juga didefinisikan. Jika Anda melihat kembali pada "res/layout/update.xml" Anda akan melihat bahwa ada bagian untuk menampilkan semua data item yang disimpan dalam database, yaitu gambar profil pengguna dan nama layar, tweet dan waktu itu secara tweeted.

Kelas adaptor akan masuk pembaruan tweet data peta untuk item view user interface. Daripada harus menerapkan ini secara manual, kelas "SimpleCursorAdapter" Mari kita mengotomatisasi bagian dari proses, memetakan data ke view sementara masih memungkinkan kita untuk menyesuaikan proses pemetaan ini sesuai dengan kebutuhan aplikasi.

Membuat sebuah class baru di app, namai itu "UpdateAdapter". extend kelas Deklarasi sebagai berikut:

 
public class UpdateAdapter extends SimpleCursorAdapter

Impor parent class dan Log kelas sebagai berikut:

 
import android.widget.SimpleCursorAdapter; 
import android.util.Log;

Menambahkan variabel instance sebagai berikut:

 
	/**twitter developer key*/ 
public final static String TWIT_KEY = "your key";//alter 
	/**twitter developer secret*/ 
public final static String TWIT_SECRET = "your secret";//alter 
	 
	/**strings representing database column names to map to views*/ 
static final String[] from = { "update_text", "user_screen",  
	"update_time", "user_img" }; 
	/**view item IDs for mapping database record values to*/ 
static final int[] to = { R.id.updateText, R.id.userScreen,  
	R.id.updateTime, R.id.userImg }; 
	 
private String LOG_TAG = "UpdateAdapter";

Ubah Twitter developer Key dan Secrect untuk mencerminkan Anda sendiri, seperti yang Anda digunakan dalam app utama aktivitas kelas dalam tutorial terakhir. "from" array mewakili nama kolom tabel database setiap yang dipetakan. "to" array mewakili id View bahwa "from" item akan dipetakan ke. Id dimasukkan dalam XML layout yang kami buat dalam tutorial terakhir.

Langkah 3: Map Data untuk User Interface

Dalam kelas adaptor Anda, menambahkan metode konstruktor sebagai berikut:

 
/** 
 * constructor sets up adapter, passing 'from' data and 'to' views 
 * @param context 
 * @param c 
 */ 
public UpdateAdapter(Context context, Cursor c) { 
	super(context, R.layout.update, c, from, to); 
}

Kode ini memanggil superclass constructor, melewati aplikasi Context, Vuew item di mana data akan ditampilkan, Cursor untuk melintasi data dan "from" dan "to" array yang kami buat sebagai variabel instan. Anda akan memerlukan impor pernyataan berikut untuk kode ini:

 
import android.content.Context; 
import android.database.Cursor;

Ini melakukan bagian tengah dari proses pemetaan, yaitu menampilkan data di dalam view tertentu. Namun, kami juga ingin menyesuaikan perilaku dan munculnya elemen user interface yang dihasilkan. Kami akan menyesuaikan prosedur pemetaan untuk mengambil gambar profil untuk setiap tweet dan format waktu update. Dalam tutorial terakhir dari seri, kami juga akan extend kode ini untuk men-setup klik listener untuk tombol retweet, tombol reply dan nama pengguna Twitter untuk setiap tweet.

Menerapkan metode "bindView" dalam kelas adaptor Anda menggunakan garis besar berikut:

 
/* 
 * Bind the data to the visible views 
 */ 
@Override 
public void bindView(View row, Context context, Cursor cursor) { 
	super.bindView(row, context, cursor); 
}

Di sini kita hanya memanggil metode superclass. Metode "bindView" yang memungkinkan kita untuk menentukan pengolahan tambahan untuk ketika data yang dipetakan ke view. Pertama mari kita coba untuk men-download gambar profil untuk tweet update saat ini:

 
try { 
		//get profile image 
	URL profileURL =  
		new URL(cursor.getString(cursor.getColumnIndex("user_img"))); 
 
		//set the image in the view for the current tweet 
	ImageView profPic = (ImageView)row.findViewById(R.id.userImg); 
	profPic.setImageDrawable(Drawable.createFromStream 
		((InputStream)profileURL.getContent(), "")); 
} 
catch(Exception te) { Log.e(LOG_TAG, te.getMessage()); }

Kita perlu try catch blok karena kita sedang berusaha untuk memuat sumber daya eksternal. Metode pertama mendapat URL gambar profil sebagai disimpan di kolom database. Maka metode mendapat referensi untuk lihat item untuk menampilkan gambar, menggunakan atribut ID yang, sementara kita dalam layout file update XML. Akhirnya kode mengambil gambar sebagai InputStream, mengimpor sebagai Drawable dan pengaturan sebagai gambar dalam ImageView. Anda akan memerlukan impor berikut:

 
import java.io.InputStream; 
import java.net.URL; 
import android.graphics.drawable.Drawable; 
import android.view.View; 
import android.widget.ImageView;

Sekarang mari kita mengubah tampilan waktu update, seperti itu akan disimpan dalam database sebagai angka. Untuk mengkonversi ke human-readable waktu relatif, tambahkan kode berikut setelah catch blok:

 
	//get the update time 
long createdAt = cursor.getLong(cursor.getColumnIndex("update_time")); 
	//get the update time view 
TextView textCreatedAt = (TextView)row.findViewById(R.id.updateTime); 
	//adjust the way the time is displayed to make it human-readable 
textCreatedAt.setText(DateUtils.getRelativeTimeSpanString(createdAt)+" ");

Pertama kita mengambil nilai kolom yang sebagai long, kemudian mendapatkan referensi ke item View untuk menampilkannya dalam sebagai bagian dari pembaruan XML. Akhirnya kita format itu sebagai String sehingga user dapat melihat ketika tweet relatif terhadap masa kini. Anda akan perlu pernyataan impor tambahan berikut:

 
import android.text.format.DateUtils; 
import android.widget.TextView;

Langkah 4: Membangun Home Timeline

Kembali ke app main aktivitas kelas "TwitNiceActivity" Mari kita sekarang menerapkan metode "setupTimeline". Dalam tutorial berikutnya kami akan menambahkan Service pemrosesan metode, tetapi untuk sekarang mari kita menangani memulai database dan adaptor. Sebelum Anda memulai pada metode, tambahkan berikut contoh variabel di atas kelas Anda:

 
	/**main view for the home timeline*/ 
private ListView homeTimeline; 
	/**database helper for update data*/ 
private NiceDataHelper timelineHelper; 
	/**update database*/ 
private SQLiteDatabase timelineDB; 
	/**cursor for handling data*/ 
private Cursor timelineCursor; 
	/**adapter for mapping data*/ 
private UpdateAdapter timelineAdapter;

Kami akan menggunakan variabel ini ketika membuat timeline. Tambahkan berikut untuk menentukan ukuran default untuk tampilan gambar profil:

 
ProfileImage.ImageSize imageSize = ProfileImage.NORMAL;

Anda akan perlu untuk menambahkan impor berikut:

 
import twitter4j.ProfileImage; 
import android.database.Cursor; 
import android.database.sqlite.SQLiteDatabase; 
import android.widget.ListView; 
import android.widget.LinearLayout;

Sekarang untuk mengatur timeline. Jika Anda membuat garis metode "setupTimeline" untuk pengujian terakhir kali, Anda dapat menambahkan tubuh metode berikutnya. Jika tidak, Buat garis metode sekarang:

 
/** 
 * setupTimeline displays the user's main home Twitter timeline 
 */ 
private void setupTimeline() { 
 
	//method body 
}

Anda mungkin ingat dari terakhir kali bahwa metode ini disebut ketika pengguna sudah memiliki wewenang aplikasi untuk menggunakan Twitter account. Dalam metode kami akan instantiate class Database Helper, mengambil readable database, instantiate kelas adaptor dan mengaturnya untuk memetakan data ke view kami. Mulai dengan menetapkan konten timeline View:

 
setContentView(R.layout.timeline);

Beberapa metode kita akan gunakan bisa throw exception, jadi berikutnya menambahkan try dan catch blok:

 
try { 
 
	//get the timeline 
} 
catch(Exception te) { Log.e(LOG_TAG, "Failed to fetch timeline: " + te.getMessage()); }

Kita akan menambahkan kutipan berikutnya kode dalam blok mencoba. Di sini kita akan ke instantiate variabel-variabel yang kita dinyatakan di atas kelas. Pertama kali mendapatkan referensi ke ListView dari tata letak timeline, di mana update View akan muncul:

 
	//get reference to the list view 
homeTimeline = (ListView)findViewById(R.id.homeList);

Selanjutnya buat instance kelas Database Helper dan menggunakannya untuk mengambil readable database:

 
	//instantiate database helper 
timelineHelper = new NiceDataHelper(this); 
 
	//get the database 
timelineDB = timelineHelper.getReadableDatabase();

Baris pertama di sini membuat instance kelas Database Helper kami didefinisikan, sementara kedua benar-benar mengambil database. Sekarang mari kita query database dan memperoleh Cursor untuk melintasi, melewati ini Cursor ke adaptor kelas:

 
	//query the database, most recent tweets first 
timelineCursor = timelineDB.query 
	("home", null, null, null, null, null, "update_time DESC"); 
	//manage the updates using a cursor 
startManagingCursor(timelineCursor); 
	//instantiate adapter 
timelineAdapter = new UpdateAdapter(this, timelineCursor);

Database query hanya mengambil segala sesuatu dari table, ordering dengan tweets update terbaru pertama. Kami melewati Cursor ke metode konstruktor kelas adaptor yang kita buat.

Berikutnya

Dalam tutorial ini kami telah membuat database timeline twett kami, yang didefinisikan adaptor untuk menampilkan data di dalam user interface view dan dimanfaatkan kelas-kelas ini dalam main activity aplikasi kami, untuk membangun timeline terlihat.

Dalam tutorial berikutnya kami akan menyiapkan Service dan Broadcast Receiver untuk terus mengambil update baru dan menampilkannya dalam user home timeline. Pada saat ketika Anda menjalankan aplikasi Anda tidak akan melihat setiap update, seperti kami tidak belum diambil user timeline. Sebagai bagian dari Service kelas kami akan mengambil timeline menggunakan metode Twitter4J, memanggil mengatur interval untuk berulang kali mengambil tweets terbaru dari account user yang mengikuti. Kami kemudian akan menulis hasil ke database dan menyajikan mereka dalam tampilan timeline.