Most of the time I use Intellij Idea Community Edition for Android development, but recently I had to switch to Eclipse for some reasons. It could be really painful because I really got used to Intellij Idea default key scheme (pdf). But, thankfully, there is simple and elegant solution for this by Santhosh Kumar. Just download the jar file and place it into plugins folder in your eclipse folder. Than restart eclipse. In eclipse go to Window -> Preferences (Windows) or ADT -> Preferences (Mac) than to General -> Keys and in the "Scheme" droplist choose "Intellij Idea" and press apply. That's it! Now you have the default Intellij Idea Keymap in your Eclipse workspace.
Application minimum required SDK version - 14 (ICS)
Contents
Intro
Creating SQLite database
Accessing SQLite database from ADB shell.
Links
1. Intro
In this tutorial we will develop a simple notepad Application for Android that allows you to create, read and edit text notes. To understand this tutorial you've got to have basic knowledge about relational databases and SQL.
The app and the idea are not mine, almost all of the code is taken from Android developers web site. The tutorial there is just awesome but there are some topics that I would like to highlight in more detail. There are also some things that are deprecated and I will replace them with new implementations and point out where it happens. We will start from a scratch and add some functionality step by step. Before reading this tutorial I highly recommend to look through the original article from Android web site. In this tutorial we are going to create a very simple database that will serve us as data storage for our app.
At the end of this tutorial you will know how to:
create a simple SQLite database in Android.
get access to SQLite database via the command prompt (terminal) and execute some simple queries.
2. Short facts about SQLite database
First, some facts about SQLite in general:
SQLite is free and open-source embedded SQL database engine.
SQLite reads and writes directly to ordinary disk files.
A complete SQL database is contained in a single disk file.
The database file format is cross-platform.
It supports standard relational database features including syntax, transactions and prepared statements. Transactions are ACID.
Database Structure
Our database will contain only one table and the following columns to persist notes:
title -- text (note title)
body -- text (note body text)
_id -- integer, autoincrement (the id of the note)
Creating the Database
Let's create a new project with default settings which contains a single activity called NotesListActivity. Now in the same package with our activity create a class called NotesDbAdapter which will contain a subclass of SQLiteOpenHelper as a subclass which is a class to manage database creation and it's versioning. NotesDbAdapter will grant us an access to our database by defining CRUD methods in it. So let's create the wrapper class for our database and define all the constants we need and static inner class to get a database connection.
public static final String COLUMN_TITLE = "title"; public static final String COLUMN_BODY = "body"; public static final String COLUMN_ID = "_id";
public static final String TAG = NotesDbAdapter.class.getSimpleName(); private DatabaseHelper mDbHelper; private SQLiteDatabase mDb;
private static final String DATABASE_NAME = "notes.db"; private static final String TABLE_NAME = "notes"; private static final int DATABASE_VERSION = 1;
private static final String DATABASE_CREATE = "create table notes (_id integer primary key autoincrement, " + "title text not null, body text not null);";
@Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { db.execSQL("DROP TABLE IF EXISTS notes"); onCreate(db); Log.d(TAG, "onUpdate() database"); } }
public NotesDbAdapter(Context context) { this.mContext = context; }
public NotesDbAdapter open() throws SQLException { mDbHelper = new DatabaseHelper(mContext); mDb = mDbHelper.getWritableDatabase(); return this; } }
The code looks quite big but actually there is nothing special here. We create static subclass of SQLiteOpenHelper and implement abstract methods onCreate() and onUpgrade(). The onCreate()method is invoked when there is no database available for our app, so in this method we have to execute all the statements to create our database. onUpgrade() is invoked when the version of the current database version is smaller than new version (database version is provided when SQLiteOpenHelper subclass instance is created and this version is passed as a parameter to a superclass constructor). NotesDbAdapter is a wrapper class that holds the instance of SQLiteOpenHelper and provides API for database access (We will define basic CRUD operations in the next tutorials). Now we need to create an instance of our NotesDbAdapter in our activity an call open() method to create the database. That's all the code we need to have a working database.
mDbHelper = new NotesDbAdapter(this); mDbHelper.open(); } }
3. Accessing SQLite Database from ADB Shell
Now we need to make sure that our database is created and in a working state. Let's open DDMS perspective in Eclipse (or launch monitor from tools folder in your SDK location) and locate the database file on the device file system. Emulator/device instances store SQLite3 databases in the folder:
To issue SQL queries to your database enter a remote shell on the emulator instance and enter sqlite3 command following with the full path to our database. Here is an example:
C:\Users\Taras Osiris>adb shell root@android:/ # sqlite3 /data/data/com.blogspot.android_by_example.notepad/databases/notes.db .android_by_example.notepad/databases/notes.db < SQLite version 3.7.11 2012-03-20 11:35:50 Enter ".help" for instructions Enter SQL statements terminated with a ";" sqlite>
On Windows to acces ADB directly from command prompt add path of your SDK to your environment variables. On Mac OS follow this instructions.
If you have only one USB device or emulator connected you don't need to specify what device is the target for your commands. Otherwise you need to direct your commands to the targeted device by specifying arguments after adb command. For more details read about issuing ADB commands.
adb [-d|-e|-s <serialNumber>] shell
Now you can execute your SQL queries directly to your database. Let's insert a few rows into our database and than query all of them.
sqlite> INSERT INTO notes (title, body) VALUES ("Title1", "Body1"); INSERT INTO notes (title, body) VALUES ("Title1", "Body1"); sqlite> INSERT INTO notes (title, body) VALUES ("Title2", "Body2"); INSERT INTO notes (title, body) VALUES ("Title2", "Body2"); sqlite> INSERT INTO notes (title, body) VALUES ("Title3", "Body3"); INSERT INTO notes (title, body) VALUES ("Title3", "Body3"); sqlite> SELECT * FROM notes; SELECT * FROM notes; 1|Title1|Body1 2|Title2|Body2 3|Title3|Body3
As you can see, everything is great, our database is fine and ready to use. In the next part of tutorial we are going to work on ListActivity that will display a list of our notes from database.
Unfortunately, I haven't found an article of the same type in English, that's why I am going to write an overview of Android adapters soon.
In this post I will make a brief overview of the simplest default Android Adapter implementation - ArrayAdapter<T>.
android.widget.ArrayAdapter<T> is a concrete class that can be instantiated with the help of one of the six constructors or using static factory method (Effective Java. Item 1)
2. When should ArrayAdapter<T> be used?
A parameterized class ArrayAdapter<T> is a very simple adapter implementation.
The default implementation is used when you have an array or List of objects of any type and you need to show user their string representation in the form of ListView, Spinner, GridViewor any other subclass of AdapterView. For string representation of an object, this adapter will use toString() method. By default this class expects that the provided resource id references a single TextView. If you want to use a more complex layout, use the constructors that also takes a field id. That field id should reference a TextView in the larger layout resource. (Documentation)
3. Using ArrayAdapter<T> in practice
ListView and Spinner of planets
Suppose we need to display a list of planets in our application (As a basis I took the API guide on developer.android.com about Spinner). The simplest case is when the set of data we need to display is predefined (we exactly know how many items we want to show and have their string representation). In this situation our set of data should be defined in the resource file and static factory method createFromResource() should be used. Create a new project with a blank activity.
First, let's define our data set in res/values/strings.xml resource file:
ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource( this, // context R.array.planets_array, // source of data android.R.layout.simple_list_item_1); // layout file to make views listViewContacts.setAdapter(adapter); } }
And don't forget to include the activity into your AndroidManifest.xml file. That's the whole code for creating a simple list of items. In this case the created adapter takes the array of data declared in the resource file and builds each item in the list using the default layout for the Android list item. The same result can be achieved by using constructor. It accepts array of objects (T[]) as in the code above or it can receive a List<T> of objects. In our case the code gets a little bit more verbose because of fetching the array from application resources. Note that in the code below the constructor receives a Listof Strings.
ArrayAdapter<String> adapter = new ArrayAdapter<String>( this, android.R.layout.simple_list_item_1, Arrays.asList(planets));
listViewContacts.setAdapter(adapter); } }
Note that in this example ListView can be substituted by any AdapterView(Spinner, GridView)
4. Conclusion
ArrayAdapter<T> is a concrete class. It should be used when we need a string representation of data in array or List is required. You can subclass it if the default implementation lacks functionality.
To instantiate an ArrayAdapter<T> object one of the constructors can be used. Or you can use static factory method createFromResource(), when data set is in the application resource file. In each case you have to provide ArrayAdapter<T> an object with the data set for string representation and a layout file for making a View
We've developed the most simple application that shows a list of planets using ArrayAdapter<T>.
