Android lessons for beginners (startandroid.ru)

Recently I have started translating lessons on startandroid.ru into English. It's a famous web site for those who want to start programming Android and have no priror experience with it. The lessons are really awesome and now English speaking audience will be able to read them. Each lesson describes one subject or feature so you can read only the lesson you need.

Join the community on Google+ to follow the news.

I've started learning Android on this web-site and now I would like to pay back the author and make some translations. The following lessons are already published:

• Lesson 1. Introduction
• Lesson 2. Installing and configuring development environment Eclipse and SDK Tools
• Lesson 3. Creating AVD. The first application. Android project structure
• Lesson 4. Layout elements and their properties
• Lesson 5. Layout-file for Activity. XML Representation. Changing screen orientation.
• Lesson 6. Layout types. Key differences and properties.
• Lesson 7. Layout parameters for View-elements.
• Lesson 8. Working with layout elements from code.
• Lesson 9. Event listeners with Button example
• Lesson 10. Optimizing event listeners implementation
• Lesson 11. res/values folder. Using application resources
• Lesson 12. Logs and Toast messages.
• Lesson 13. Creating a simple menu
• Lesson 14. Menu, groups, order. MenuInflater and xml-menu
• Lesson 15. Context menu
• Lesson 16. Creating layout programmatically. LayoutParams
• Lesson 17. Creating View-components in a running application
• Lesson 18. Changing layoutParams in a running application
• Lesson 19. Creating a simple calculator
• Lesson 20. Animation
• Lesson 21. Creating and starting an Activity
• Lesson 22. Intent, Intent Filter, Context - theory
• Lesson 23. Activity Lifecycle. Activity states
• Lesson 24. Activity Lifecycle, example about changing states with two Activities
• Lesson 25. Task. What is it and how it is formed.
• Lesson 26. Intent Filter - practice
• Lesson 27. Reading action from Intent
• Lesson 28. Extras - passing data using Intent
• Lesson 29. Invoking Activity and getting a result. startActivityForResult method.

So Android beginners, welcome! And let's study together!

You can find the complete list of lessons published here.

How to enable USB debugging on Android 4.2

To enable USB Debugging and make Developer options appear in Settings menu, just go to Settings ->About phone/tablet and tap Build number 7 times.

That's it! Now you have Developer options available in your device Settings.

Eclipse doesn't open Android XML Library files.

Recently I ran into an issue that Eclipse didn't want to open XML files that are located in android.jar/res.layout directory. The reason is that android uses Android Common XML Editor. The only thing to do to open binary xml files is to change default XML Editor to Android Binary XML Editor. To do so go to Window -> Preferences -> General -> Editors -> File Associations and change default XML Editor to Android Binary XML Editor.

Could not open the editor.

Problem Solution

Intellij Idea key scheme for Eclipse

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.

Links:

• Intellij Idea default key scheme (pdf)
• Eclipse default key scheme (pdf)
• Plugin for eclipse (jar)
• Plugin web site

Developing Notepad Application - Part 1 (Creating SQLite database)

Application minimum required SDK version - 14 (ICS)

Contents

1. Intro
2. Creating SQLite database
3. Accessing SQLite database from ADB shell.
4. 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.

NotesDbAdapter.java

package com.blogspot.android_by_example.notepad;

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

public class NotesDbAdapter {

 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);";
 
 private final Context mContext;

 private static class DatabaseHelper extends SQLiteOpenHelper {
  DatabaseHelper(Context context) {
   super(context, DATABASE_NAME, null, DATABASE_VERSION);
  }
  
  @Override
  public void onCreate(SQLiteDatabase db) {
   db.execSQL(DATABASE_CREATE);
   Log.d(TAG, "onCreate() database");
  }

  @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.

NotesListActivity.java

package com.blogspot.android_by_example.notepad;

import android.os.Bundle;
import android.app.Activity;

public class NotesListActivity extends Activity {
 
 private NotesDbAdapter mDbHelper;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_notes_list);
        
        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:

/data/data/<package_name>/databases/<database_name>

So in our case the database will be located at:

/data/data/com.blogspot.android_by_example.notepad/databases/notes.db

Database file location

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.

Links and Materials Used

• Android SQLite Database and ContentProvider Tutorial at vogella.com
• Issuing ADB command in android and using SQLite from shell
• SQLite in Android (rus)

Using ArrayAdapter (Creating list or spinner with a set of predefined data)

Application minimum required SDK version - 8

Contents

1. Preface
2. When should ArrayAdapter<T> be used?
3. Using ArrayApater<T> default implementation in practice
4. Conclusion
5. Links

1. Preface

For this article to be useful, basic knowledge about Adapter objects in Android is required. 

For those readers who know Russian, have a look at this article - Android Adapters Overview (rus).

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, GridView or 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:

<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string-array name="planets_array">
        <item>Mercury</item>
        <item>Venus</item>
        <item>Earth</item>
        <item>Mars</item>
        <item>Jupiter</item>
        <item>Saturn</item>
        <item>Uranus</item>
        <item>Neptune</item>
    </string-array>

</resources>

Now let's create a layout file (res/layout/activity_planets.xml) which contains a single ListView:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <ListView
        android:id="@+id/listViewPlanets"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" >
    </ListView>

</LinearLayout>

And finally our PlanetsActivity.java :

package com.blogspot.android_by_example;

import android.os.Bundle;
import android.app.Activity;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class PlanetsActivity extends Activity {

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_planets);
  
  ListView listViewContacts = (ListView) findViewById(R.id.listViewPlanets);

  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 List of Strings.

package com.blogspot.android_by_example;

import java.util.Arrays;

import android.os.Bundle;
import android.app.Activity;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class PlanetsActivity extends Activity {

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_planets);

  ListView listViewContacts = (ListView) findViewById(R.id.listViewPlanets);
  String[] planets = getResources().getStringArray(R.array.planets_array);
  
  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>.

5. Links

• Android Adapters Overview (in russian)
• Android Documentation ArrayAdapter<T>
• Creating a default Spinner in Android

Download the source code

Jelly Bean: Accessibility Gestures Explained

1 Jelly Bean: Accessibility Gestures Explained

This article details accessibility gestures in Jelly Bean and is a follow-up to Jelly Bean Accessibility Explained. It gives a conceptual overview of the 16 possible gestures and describes how they are used. The interaction behavior described here holds for all aspects of the Android user interface, including interactive Web pages within Chrome and the Android Web Browser.

1.1 Conceptual Overview Of The Gestures

Placing a finger on the screen speaks the item under the finger by first placing Accessibility Focus on that item. Moving the finger triggers touch exploration which moves Accessibility Focus.

To generate any of the Accessibility Gestures discussed below, one moves the finger much faster — how much faster is something we will tune over time, and if needed, make user customizable.

To remember the gestures, think of the four directions, Up, Down, Left and Right. In addition to these four basic navigational gestures, we defined an additional 12 gestures by picking pairwise combinations of these directional flicks, e.g., Left then Down — this gives a total of 16 possible gestures. In what follows, left then down means swipe left, and continue with a down flick. Note that in performing these additional gestures, speed matters the most. As an example, it is not essential that you make a perfect Capital L when performing the Down then Right gesture for instance; speed throughout the gesture, as well as ensuring that the finger moves some distance in each direction is key to avoid these being misinterpreted as basic navigational gestures.

1.2 Accessibility Focus And Accessibility Gestures

Accessibility Focus is moved using the four basic directional gestures. For now we have aliased Left with Up, and Downwith Right; i.e., both Left and Up move to the previous item, whereas Down and Right move to the next item. Note that this is not the same as moving with a physical D-Pad or keyboard on Android; the Android platform moves System Focus in response to the D-Pad. Thus, moving with a D-Pad or trackball moves you through the various interactive controls on the screen; moving Accessibility Focus via the Accessibility Gestures moves you through everything on the screen.

1.3 Accessibility Gestures For Common Actions

In addition to the basic navigation describe above, we define the following gestures for common actions:

Navigation Granularity

You can increase or decrease navigation granularity by rapidly stroking Up then Down or Down then Up.

Scrolling Lists

You can scroll a list forward by rapidly stroking Right then Left; the reverse, i.e., Left then Right scrolls the list backward by a screenful.

1.4 User Configurable Gestures

Gestures Down then Left, Up then Left, Down then Right and Up then Rightare user configurable; their default assignments are shown below.

Back

Gesture Down then Left is the same as pressing the Back button.

Home

Up then Left has the same effect as pressing the Home button.

Status Bar

Gesture Up then Right opens Status Notifications.

Recent

Down then Right has the same effect as pressing the Recent Applications button.

1.5 Summary

Gestures for manipulating and working with Accessibility Focus are an evolving part of the Android Accessibility; we will continue to refine these based on user experience. At this point, you are probably saying:

But wait, you said 16 gestures, but only told us the meanings of 12 of them

You are correct — we have left ourselves some gestures to use for future features.