It is entirely written in Java and offers you the possibility to download additional artist information and cover images. You are also able to edit the files’ ID3 tags which contain the song title, album and artist name.

The player is also extendable by providing downloadable plugins. There is a plugin which enables you to convert an MP3 file to a WAV file so you can burn an album onto a regular music CD.

In addition the player is skinnable through custom themes.

Features

• manage and view your entire music library with ease
• ability to view and edit ID3 tags that are embedded within mp3 files
• show detailed information about a song, an album or an artist
• possibility to automatically search for artist information on the Web
• retrieve and view album cover images and images of artists
• space saving tiny view
• intelligent search function
• extensible through plugins and themes
• comfortable user interface
• integrated update function: keep your VibrantPlayer up to date
• free of charge and open-source!

Screen shots

Download

Download nowfor Windows: .zip (14.0 MB)Download nowfor Linux/Mac: .tar.gz (13.9 MB)

Download srcsources: .zip (14.9 MB)

This time I will show you how to enhance this demo program by displaying the associated package file location of a selected app as well as the amount of disk space it consumes on your phone. In addition, we will add the possibility to uninstall a selected app.

Displaying the package location and file size

The first improvement that we will make on the demo app is to display the path where the app is actually installed and the size on disk that it consumes. To store this information our App bean will get two new String fields: installDir and installSize complete with accompanying getters and setters.

We then have to extend our listInstalledApps(...) method inside our main activity:

app.setInstallDir(p.applicationInfo.sourceDir);
app.setInstallSize(calculateSize(app.getInstallDir()));

The calculateSize(...) method is a custom method that takes the path to the installed package as a parameter and returns a human-readable form of the file’s size, e.g. “420.23 KB” or “1.23 MB”. It is implemented as follows:

private String calculateSize(String installPath) {
  File file = new File(installPath);

  String unit = "Bytes";
  double sizeInUnit = 0d;

  if (file.exists()) {
    double size = (double) file.length();

    if (size > 1024 * 1024 * 1024) { // Gigabyte
      sizeInUnit = size / (1024 * 1024 * 1024);
      unit = "GB";
    } else if (size > 1024 * 1024) { // Megabyte
      sizeInUnit = size / (1024 * 1024);
      unit = "MB";
    } else if (size > 1024) { // Kilobyte
      sizeInUnit = size / 1024;
      unit = "KB";
    } else { // Byte
      sizeInUnit = size;
    }
  }

  // only show two digits after the comma
  return new DecimalFormat("###.##").format(sizeInUnit) + " " + unit;
}

The only thing that is left to do now is to display the gathered information to the user. We do this inside our dialog box that is shown upon selection of an app in the list:

AlertDialog dialog = new AlertDialog.Builder(this).create();

String msg = app.getTitle() + "\n\n" +
  "Version " + app.getVersionName() + " (" + app.getVersionCode() + ")" +
   "\n" + app.getDescription() + "\n" +
  app.getInstallDir() + "\n" + app.getInstallSize();
dialog.setTitle(app.getTitle());
dialog.setMessage(msg);

The user can now see where the selected app is installed and how much space it consumes.

Adding the ability to uninstall a selected app

We will also add the ability to uninstall a selected app. This can be achieved very easily: all you have to do is execute an intent to remove a given package name. We will add a third button to our dialog box which enables the user to unsinstall the selected app:

dialog.setButton(AlertDialog.BUTTON_NEGATIVE, "Uninstall",
  new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
      Intent intent = new Intent(Intent.ACTION_DELETE);
      intent.setData(Uri.parse("package:" + app.getPackageName()));
      startActivity(intent);
      mApps.remove(appPosition);
      mAdapter.notifyDataSetChanged(); // update the UI
    }
});

That’s all there is to it! Android will do the rest for you including showing an additional activity where the user has to confirm his choice to actually remove the selected app for good.

As always you can download the sample application containing all source code and layout resource files:

Download now.zip (71 KB)

In this tutorial we will enhance the demo program by adding an application icon next to each title and also display some information about the app when clicking on it. The user can then choose to start the app or return to the list.

Layout changes

We will only adapt the layout of a row in the list by adding an ImageView next to the TextView which holds the app’s title. Since we will need to update the image programmatically we assign an id to it.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="horizontal"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent">
  <ImageView
    android:id="@+id/appicon"
    android:scaleType="fitCenter"
    android:layout_width="40dp"
    android:layout_height="40dp"
    android:layout_marginRight="6dip"
    android:layout_marginLeft="2dip"
    android:layout_marginTop="2dip"
    android:layout_marginBottom="2dip"
    android:src="@drawable/icon"
    android:layout_gravity="center_vertical" />
  <TextView
    android:id="@+id/apptitle"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:textSize="20dip"
    android:layout_gravity="center_vertical" />
</LinearLayout>

Code adaptations

We will first need to modify our custom list adpater class AppListAdapter. The class will get a map containing the app’s package names mapped to the respective icon images. We also need to provide a getter and setter for this field. We will also add a default image which is shown before the icons are loaded and when no icon could be found for a particular app.

Last but not least we will update our ViewHolder object to also hold an ImageView for the current row. This view is retrieved through the id we gave it in the layout earlier. The icon will be taken from the map that we just defined.

public class AppListAdapter extends BaseAdapter {
  // ...

  // a map which maps the package name of an app to its icon drawable
  private Map<String, Drawable> mIcons;
  // default icon for each app until the actual icon is loaded
  private Drawable mStdImg;

  /**
   * Constructor.
   *
   * @param context the application context for the layout inflater
   */
  public AppListAdapter(Context context) {
    // ...

    // set the default icon until the actual icon is loaded for an app
    mStdImg = context.getResources().getDrawable(R.drawable.icon);
  } 

  // ...

  @Override
  public View getView(int position, View convertView, ViewGroup parent){

    AppViewHolder holder;
    if (convertView == null) {
      convertView = mInflater.inflate(R.layout.row, null);
      holder = new AppViewHolder();
      holder.mTitle = (TextView) convertView.findViewById(R.id.apptitle);
      holder.mIcon = (ImageView) convertView.findViewById(R.id.appicon);
      convertView.setTag(holder);
    } else {
      holder = (AppViewHolder) convertView.getTag();
    }

    App app = mApps.get(position);

    holder.setTitle(app.getTitle());
    if (mIcons == null || mIcons.get(app.getPackageName()) == null) {
      holder.setIcon(mStdImg);
    } else {
      holder.setIcon(mIcons.get(app.getPackageName()));
    }

    return convertView;
  }

  // ...

  /**
    * Sets the map containing the icons for each displayed app.
    *
    * @param icons the map which maps the app's package name to its icon
    */
  public void setIcons(Map<String, Drawable> icons) {
    this.mIcons = icons;
  }

  /**
   * Returns the map containing the icons for each displayed app.
   *
   * @return a map with a mapping of package names to icon drawables
   */
  public Map<String, Drawable> getIcons() {
    return mIcons;
  }

  /**
   * A view holder which is used to re/use views inside a list.
   */
  public class AppViewHolder {

    // ...

    private ImageView mIcon;

    // ...

    /**
     * Sets the icon to be shown next to the app's title
     *
     * @param img the icon drawable to be displayed
     */
    public void setIcon(Drawable img) {
      if (img != null) {
        mIcon.setImageDrawable(img);
      }
    }
  }
}

Please refer to the first tutorial for the parts of the code which are left out for brevity.

Using an asynchroneous task to load the icons

Since it can take quite a while to load all the icon images for all installed applications and we don’t want our app to be unresonsive I decided to first display the list of installed apps and then load the images asynchroneously. This is done using an AsyncTask which makes multi-threading really easy. All you have to do is create a class which extends AsyncTask and override its doInBackground(...) method to perform all the work there is to do and which should not happen on the UI thread as it would block the process of painting the elements on the screen.

Once we are finished loading the images, we signalize that the dataset of the list has changed. This is done in the onPostExecute(...) method:

private class LoadIconsTask extends AsyncTask<App, Void, Void> {
  @Override
  protected Void doInBackground(App... apps) {

    Map<String, Drawable> icons = new HashMap<String, Drawable>();
    PackageManager manager = getApplicationContext().getPackageManager();

    for (App app : apps) {
      String pkgName = app.getPackageName();
      Drawable ico = null;
      try {
        Intent i = manager.getLaunchIntentForPackage(pkgName);
        if (i != null) {
          ico = manager.getActivityIcon(i);
        }
      } catch (NameNotFoundException e) {
        Log.e("ERROR", "Unable to find icon for package '" + pkgName);
      }
      icons.put(app.getPackageName(), ico);
    }
    mAdapter.setIcons(icons);

    return null;
  }

  @Override
  protected void onPostExecute(Void result) {
    mAdapter.notifyDataSetChanged();
  }
}

Showing additional information about the selected app

Finally, we will extend our original demo program by showing an informative dialog whenever an entry is selected in the list. We offer the user the possibility to launch the selected app or abort and get back to the app list.

@Override
public void onItemClick(AdapterView<?> p, View view, int pos, long id) {

  final App app = (App) parent.getItemAtPosition(pos);
  String pkg = app.getPackageName();

  AlertDialog.Builder builder = new AlertDialog.Builder(this);

  String msg = app.getTitle() + "\n\nVersion " + app.getVersionName() +
    " (" + app.getVersionCode() + ")\n\n" +
    (app.getDescription() != null ? app.getDescription() : "");

    builder.setMessage(msg)
      .setCancelable(true)
      .setTitle(app.getTitle())
      .setIcon(mAdapter.getIcons().get(pkg))
      .setPositiveButton("Launch",new DialogInterface.OnClickListener(){
        public void onClick(DialogInterface dialog, int id) {
          // start the app by invoking its launch intent
          Intent i = getPackageManager().getLaunchIntentForPackage(pkg);
          try {
            if (i != null) {
              startActivity(i);
            }
          } catch (ActivityNotFoundException err) {
            Toast.makeText(ListInstalledApps.this, "App launch failed!",
              Toast.LENGTH_SHORT).show();
          }
        }
      })
      .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) {
          dialog.cancel();
        }
      });
  AlertDialog dialog = builder.create();
  dialog.show();
}

You can download the sample application containing all source code and layout resource files:

Download now.zip (66.8 KB)

The layout

As I mentioned, the GUI will be fairly simple. We will only need to define a layout file for our main activity and one for each entry of the app list.

The main activity simply contains a list which spans the entire screen:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent">
    <ListView android:id="@+id/appslist"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content" />
</LinearLayout>

The layout for a row of that list is equally simple: we will only display a textview which will hold the app’s name:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="horizontal"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent">
  <TextView
    android:id="@+id/apptitle"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:textSize="20dip"
    android:layout_gravity="center_vertical" />
</LinearLayout>

The code

We will first create a simple Java bean which will hold the interesting attributes of an app. It merely consists of a few fields and respective getters and setters:

public class App {

  private String title;
  private String packageName;
  private String versionName;
  private int versionCode;

  // ...getters and setters omitted...
}

Next up is a custom list adapter which we will use to render our list of apps. It will hold a reference to the list of App beans that it is displaying. Don’t worry about the ViewHolder class too much; it is only used to reuse views and speed things up.

public class AppListAdapter extends BaseAdapter {

  private LayoutInflater mInflater;
  private List<App> mApps;

  public AppListAdapter(Context context) {
     // cache the LayoutInflater to avoid asking for a new one each time
     mInflater = LayoutInflater.from(context);
  }

  @Override
  public int getCount() {
    return mApps.size();
  }

  @Override
  public Object getItem(int position) {
    return mApps.get(position);
  }

  @Override
  public long getItemId(int position) {
    return position;
  }

  @Override
  public View getView(int pos, View convertView, ViewGroup parent) {

    AppViewHolder holder;
    if (convertView == null) {
      convertView = mInflater.inflate(R.layout.row, null);

      // creates a ViewHolder and stores a reference to the child view
      holder = new AppViewHolder();
      holder.mTitle = (TextView) convertView.findViewById(R.id.apptitle);
      convertView.setTag(holder);
    } else {
      // reuse/overwrite the view passed assuming(!) that it is castable!
      holder = (AppViewHolder) convertView.getTag();
    }
    holder.setTitle(mApps.get(pos).getTitle());

    return convertView;
  }

  public void setListItems(List<App> list) {
    mApps = list;
  }

  /**
   * A view holder which is used to reuse views inside a list.
   */
  public class AppViewHolder {

    private TextView mTitle;

    /**
     * Sets the text to be shown as the app's title
     *
     * @param title the text to be shown inside the list row
     */
     public void setTitle(String title) {
       mTitle.setText(title);
     }
  }
}

So far, so easy. Now comes the most interesting class: our main activity which handles the retrieval of the installed apps as well as the start of an app when it’s title is being pressed in the list.

public class ListInstalledApps extends Activity
implements OnItemClickListener {

  /** whether or not to include system apps */
  private static final boolean INCLUDE_SYSTEM_APPS = true;

  private ListView mAppsList;
  private List<App> mApps;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    mAppsList = (ListView) findViewById(R.id.appslist);
    mAppsList.setOnItemClickListener(this);

    mApps = loadInstalledApps(INCLUDE_SYSTEM_APPS);

    AppListAdapter adapter = new AppListAdapter(getApplicationContext());
    adapter.setListItems(mApps);
    mAppsList.setAdapter(adapter);
  }

  @Override
  public void onItemClick(AdapterView<?> p, View v, int pos, long id) {
    // start the app by invoking its launch intent
    App app = (App) parent.getItemAtPosition(position);
    Intent i = getPackageManager().getLaunchIntentForPackage(
      app.getPackageName());
    try {
      if (i != null) {
        startActivity(i);
      } else {
        i = new Intent(app.getPackageName());
        startActivity(i);
      }
    } catch (ActivityNotFoundException err) {
      Toast.makeText(ListInstalledApps.this, "Error launching app",
        Toast.LENGTH_SHORT).show();
    }
  }

  /**
   * Uses the package manager to query for all currently installed apps
   * which are put into beans and returned in form of a list.
   *
   * @param includeSysApps whether or not to include system apps
   * @return a list containing {@code App} beans
   */
  private List<App> loadInstalledApps(boolean includeSysApps) {
    List<App> apps = new ArrayList<App>();

    // the PackageManager contains information about installed apps
    PackageManager packageManager = getPackageManager();

    List<PackageInfo> pgs = packageManager.getInstalledPackages(0);

    for(int i=0; i < pgs.size(); i++) {
      PackageInfo p = pgs.get(i);
      ApplicationInfo a = p.applicationInfo;
      // skip system apps if they shall not be included
      if ((!includeSysApps) &&
         ((a.flags & ApplicationInfo.FLAG_SYSTEM) == 1)) {
        continue;
      }
      App app = new App();
      app.setTitle(p.applicationInfo.loadLabel(packageManager)
        .toString());
      app.setPackageName(p.packageName);
      app.setVersionName(p.versionName);
      app.setVersionCode(p.versionCode);
      apps.add(app);
    }
    return apps;
  }
}

The code contains two interesting blocks. The first one is the final block which starts at line 45. It displays the usage of the PackageManager in order to retrieve the installed packages. I then create a new instance of an App bean and store the most interesting information about each installed package.

The other interesting block starts at line 25 and contains the code that is necessary to launch a selected app. It uses the application’s package name to find its launch intent. If that intent can be retrieved it is executed. Note that our activity is implementing the OnItemClickListener and sets the listener on the list view on line 16.

That is all the magic. Thanks to the PackageManager class it is very easy to retrieve the list of installed apps on a phone!

The result

The following screenshot shows how this app looks like on my emulator:

As always you can download the source code to this tutorial:

Download now.zip (55.7 KB)

In a future tutorial I will show you how to add the application’s icon as well as version information to the list.

This tutorial will show you how easy it is to add a background image to a JPanel and thereby making your application look prettier and probably more exciting to use!

How will it look like?

The following shows an example of an otherwise pretty dull user interface which got enriched by a background image making the application more exciting and fun to use.

The image from the screenshot was taken from www.theblackparade.de (the site does no longer exist).

How it is done

We create an ordinary JPanel and override its paintComponent(Graphics g) method. Within this method we paint the background image:

public class JBackgroundPanel extends JPanel {
  private BufferedImage img;

  public JBackgroundPanel() {
    // load the background image
    try {
      img = ImageIO.read(new File("./back.jpg"));
    } catch(IOException e) {
      e.printStackTrace();
    }
  }

  @Override
  protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    // paint the background image and scale it to fill the entire space
    g.drawImage(img, 0, 0, getWidth(), getHeight(), this);
  }
}

As usual we can now add any kind of component to our JPanel. Finally, we add our background image panel to a JFrame.

// create the panel with the background image
JBackgroundPanel bgPanel = new JBackgroundPanel();

// add some elements...
bgPanel.add(new JLabel("Applications don't have to look boring!"));
bgPanel.add(new JComboBox(new String[] {"Background 1", "Background 2"}));
bgPanel.add(new JButton("True"));

// create a window
JFrame f = new JFrame("JPanel with background image");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setSize(500, 250);
f.setLocationRelativeTo(null);

// add the panel with the background image
f.add(bgPanel);

// show the window
f.setVisible(true);

Of course you could set the image path in the constructor of the JBackgroundPanel class and thereby making its usage much more flexible.

That’s it. With the use of this simple trick you will be able to design attractive windows that will make the user of your app enjoy working with it. Just make sure not to use too many image or images that distract the user!

The basics: adding the necessary permissions

In order to retrieve the current GPS sensor information the user of your app must grant the android.permission.ACCESS_FINE_LOCATION permission. Add it to your app’s manifest:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
  package="de.impressive.artworx.tutorials.gps"
  android:versionCode="1"
  android:versionName="1.0">
  <application android:icon="@drawable/icon"
    android:label="@string/app_name">
    <activity android:name=".GPSTest" android:label="@string/app_name">
      <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
      </intent-filter>
    </activity>
  </application>
  <uses-sdk android:minSdkVersion="4" />
  <uses-permission
    android:name="android.permission.ACCESS_FINE_LOCATION" />
</manifest>

The layout

The layout of this sample app will be very simple: it will only contain a text view which we use to display the current position. To get a hold on this text view from within our code, we assign a new id called infotext to it:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent">
  <TextView
    android:id="@+id/infotext"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/app_name" />
</LinearLayout>

The code

Now comes the interesting part. We only need one main activity which implements the LocationListener interface. This listener informs us about location changes as well as status updates to the GPS signal.

public class GPSTest extends Activity implements LocationListener {

  private TextView mInfoText;
  private LocationManager mLoc;

  // update every 10 seconds
  private static final Integer MINIMUM_UPDATE_INTERVAL = 10000;
  // update every 10 meters
  private static final Integer MINIMUM_UPDATE_DISTANCE = 10;

  @Override
  public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);

     // get a handle to the text view to display the GPS location data
     mInfoText = (TextView) findViewById(R.id.infotext);

     // allows access to the current location and GPS status
     mLoc = (LocationManager) getSystemService(LOCATION_SERVICE);
  }

  @Override
  protected void onResume() {
    // add a location listener and request updates every 10000ms or 10m
    mLoc.requestLocationUpdates(LocationManager.GPS_PROVIDER,
      MINIMUM_UPDATE_INTERVAL, MINIMUM_UPDATE_DISTANCE, this);
    super.onResume();
  }

  @Override
  protected void onPause() {
    // GPS, as it turns out, consumes battery like crazy
    mLoc.removeUpdates(this);
    super.onPause();
  }

  @Override
  protected void onStop() {
    // may as well just finish since saving the state is not important
    finish();
    super.onStop();
  }

  @Override
  public void onLocationChanged(Location loc) {
    // display some information based on the current position
    String title = "Your current location is:\n\n";
    StringBuilder sb = new StringBuilder(title);
    sb.append("Longitude: ");
    sb.append(loc.getLongitude());
    sb.append('\n');
    sb.append("Latitude: ");
    sb.append(loc.getLatitude());
    sb.append('\n');
    sb.append("Altitiude: ");
    sb.append(loc.getAltitude());
    sb.append('\n');
    sb.append("Accuracy: ");
    sb.append(loc.getAccuracy());
    sb.append('\n');
    sb.append("Timestamp: ");
    Date timestamp = new Date(loc.getTime());
    sb.append(new SimpleDateFormat().format(timestamp));
    mInfoText.setText(sb.toString());
  }

  @Override
  public void onProviderDisabled(String provider) {
    // called if/when the GPS is disabled in settings
    Toast.makeText(this, "GPS disabled", Toast.LENGTH_LONG).show();
    // end program since we depend on GPS
    AlertDialog.Builder alertbox = new AlertDialog.Builder(this);
    alertbox.setMessage("This app requires GPS. Please activate it!");
    alertbox.setNeutralButton("Ok",
      new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface arg0, int arg1) {
          finish();
        }
      }
    );
    alertbox.show();
  }

  @Override
  public void onProviderEnabled(String provider) {
    Toast.makeText(this, "GPS enabled", Toast.LENGTH_LONG).show();
  }

  @Override
  public void onStatusChanged(String prov, int status, Bundle b) {
    // called upon GPS status changes
    switch (status) {
    case LocationProvider.OUT_OF_SERVICE:
      Toast.makeText(this, "Status changed: out of service",
        Toast.LENGTH_LONG).show();
      break;
    case LocationProvider.TEMPORARILY_UNAVAILABLE:
      Toast.makeText(this, "Status changed: temporarily unavailable",
        Toast.LENGTH_LONG).show();
      break;
    case LocationProvider.AVAILABLE:
      Toast.makeText(this, "Status changed: available",
        Toast.LENGTH_LONG).show();
      break;
    }
  }
}

The heart and soul of this code is the LocationManager. It will give us access to the current GPS data as well as inform us about status updates.

We override the onPause, onResume and onStop methods mainly to stop/resume the GPS updates so we can save our precious battery.

The onLocationChanged method is the most important one as it informs us whenever a change in the location is detected. How often these changes are notified depends on the minimum update interval as well as the minimum update distance which I defined as contants.

The final three overridden methods handle GPS sensor status updates such as disabling the GPS sensor etc.

Interacting with the emulator

In order to test the code you can either upload your app to your phone and walk around with it or use the emulator that comes with the SDK. The emulator can also simulate a GPS sensor and you can fool it by sending any location coordinates to it that come to your mind.

You first need to launch your app in the emulator. Then open a terminal window and use the following command to connect to the emulator:

telnet localhost 5554

Now you should see a command prompt which allows you to send instructions to the emulator. To send a location you need to type the following:

geo fix -31.9667 115.8325

The result should instantly be visible in your emulator window:

In a future blog post I will show you how to display this location on a map.

As always, you can download the source code for this tutorial.

Download now.zip (48.6 KB)

Defining the launch screen

The layout of the launch screen will be fairly simple: we will only display an image which will span the entire available space. Of course you can also choose to use a more sophisticated layout but for simplicity I will keep things simple and easy.

Defining the layout

Create a new file called splash.xml into the /res/layout directory of your project. Add the following contents to it:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   android:orientation="vertical"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent">
   <ImageView
      android:src="@drawable/splashimg"
      android:layout_width="fill_parent"
      android:layout_height="fill_parent"
      android:scaleType="fitCenter" />
</LinearLayout>

Note that I reference an image file called splashimg.jpg here which must be present inside your /res/drawable folder. You can find a sample image in the downloadable zip archive which is attached at the end of this post.

Implementing the splash screen activity

Now we need to add an activity to your project which will be shown when the app is started. Create a new class called SplashActivity and add the following code to it:

public class SplashScreen extends Activity {

   private boolean mActive = true;
   private int mSplashTime = 4000; // display time in ms

   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);

      // hide the app title and also the notification bar
      requestWindowFeature(Window.FEATURE_NO_TITLE);
      getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);

      setContentView(R.layout.splash);

      // thread for displaying the splash screen
      Thread splashThread = new Thread() {
         @Override
         public void run() {
            try {
               int waited = 0;
               while(mActive && (waited < mSplashTime)) {
                  sleep(100);
                  if(mActive) {
                     waited += 100;
                  }
               }
            } catch(InterruptedException e) {
               // do nothing
            } finally {
               Intent i = new Intent(getApplicationContext(),
                  MainActivity.class);
               startActivity(i);
               finish();
            }
         }
      };
      splashThread.start();
   }

   @Override
   public boolean onTouchEvent(MotionEvent event) {
      if (event.getAction() == MotionEvent.ACTION_DOWN) {
         mActive = false;
      }
      return true;
   }
}

So what is going on here? In lines 11-14 we hide the status and title bar of the phone as we want our splash screen to be shown only. After specifying the layout that we previously defined we start a new thread (line 19) which checks every 100 milliseconds whether the specified duration has been reached. If not, the thread sleeps for another 100ms. Once the specified duration is reached, the activity’s finish() method is called signaling the system that we are done. A new intent is then fired which launches our actual main application.

The overridden onTouchEvent method checks whether the screen has been touched and flips the mActive flag if so. The aforementioned thread regards this flag and aborts even when the duration has not been reached, yet.

Putting it all together

Since the launch screen is an additional activity in your project you will need to add it to your application’s manifest file and define it as the starting point of your app:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
  package="de.impressive.artworx.tutorials.splash"
  android:versionCode="1" android:versionName="1.0">
  <application android:icon="@drawable/icon"
    android:label="@string/app_name">
    <activity android:name=".SplashScreen"
      android:label="@string/app_name">
      <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
      </intent-filter>
    </activity>
    <activity android:name=".MainActivity">
      <intent-filter>
        <action android:name=
          "de.impressive.artworx.tutorials.splash.MainActivity" />
        <category android:name="android.intent.category.DEFAULT" />
      </intent-filter>
    </activity>
  </application>
  <uses-sdk android:minSdkVersion="3" />
</manifest>

You can donwload the entire sample project and use it as a starting point for your own app!

Download now.zip (120 KB)

From a software design point of view, this is achieved by introducing an enum which can hold these three values:

enum CHOICE {
   YES,
   NO,
   MAYBE
}

CHOICE myChoice = CHOICE.MAYBE;

if (myChoice == CHOICE.YES) {
   // yes
} elseif (myChoice == CHOICE.NO) {
   // no
} else {
   // maybe
}

But sometimes, this generates too much boilerplate code. Instead, you can use this tiny trick: use the Boolean wrapper class instead and define a Boolean value which can either be true (= yes), false (= no) or null (= maybe). As long as the value is not initialized you treat it as maybe:

Boolean choice;

if (choice == null) {
   // maybe
} else if (choice) {
   // yes (through auto-unboxing)
} else {
  // no
}

Several of these emulator skins already come out of the box but if you want to mimic a real device such as the HTC Hero you have the ability to install additional ones.

The HTC Hero emulator skin looks just like the real device; it will make developing and testing your apps more fun!

Installation

First you need to download the zip archive which contains all necessary files.

Download now.rar (93.5 KB)

Extract the files inside the zip archive into your android SDK’s platforms folder, e.g.

C:\android\sdk_r07\android-sdk-windows\platforms\android-7\skins

There should now be a folder called HTC_HERO within this directory.

Inside eclipse you have to open the Android SDK and AVD Manager (under the menu entry “Window”). There, create a new virtual device.

Choose a name of your liking (e.g. “HTC-Hero”) and select “Android 2.1-update1 – API Level 7″ as target. Under skin you will now be able to select “HTC_HERO” as shown in the screen shot below.

Launch

Now you can run your app and select the newly created virtual device as the launch target.

Et voilà! You will see your app running in your virtual HTC Hero device!