Near Field Communication with Android Cookbook: Discover the endless possibilities of using Android NFC capabilities to enhance your apps through over 60 practical recipes

Make sure you have an NFC-enabled Android device or a virtual test environment—refer to the Testing your app all together recipe.

We will start by creating an Android project where we will request the correct permissions, as shown in the following steps:

Android requires every app to request permissions from the user to allow the application to perform restricted actions. Examples of restricted actions include access to users' current location, permission to send an SMS without user interaction permission to, read contacts, and many others. This is done in the AndroidManifest.xml file using the <uses-permission/> node. Permissions are granted by the user when the application is installed. Requesting unnecessary permissions may cause users to not trust the application and refrain from installation. If we do not request permissions in the manifest and try to do restricted actions, an exception is thrown and the application will not work correctly.

We are going to continue adding functionality to the previously created project by declaring the features required by our application in the manifest as follows:

The Android market uses this information in the manifest to filter the apps visible to the users. This way, if your device doesn't support a required feature of an app, there's no need for that app to appear listed; it will still be listed on the website but we cannot install it since it's incompatible. This application node is not required, but it's a good idea to place it. Otherwise, the user will be disappointed with the app—it will probably just crash or show an an error occurred! message. Users don't like that, and this results in a bad rating.

An alternative is to have multiple approaches for the same result. For example, if the user's device isn't NFC enabled, use a QR code instead (when applicable).

We are going to define the minimum required version of Android to enable our application to use NFC features, as follows:

When we add the previous line to the manifest file, Eclipse will automatically scan our code and warn us of incompatible pieces of code. This is also used in the market to filter searches for apps that our devices are able to run. NFC-related features are consistently being added and improved in the latest Android releases; so, depending on your application specifications, you may need to target a higher version.

We'll create an application that shows a Toast saying whether the device has the NFC adapter, as follows:

Android provides a simple way to request the Adapter object by calling getDefaultAdapter([context]). If a valid NfcAdapter instance is returned, the NFC adapter is available; however, we still need to check if it is enabled by calling the isEnabled() method. Otherwise, we need to inform the user that the application may not function correctly as NFC is a required feature. Testing the result for a null value is the simplest way to know if NFC is available to us. However, we can also use the hasSystemFeature method from the PackageManager class to do this validation.

Testing for NFC is an operation that we will probably do very often. So, we can create a simple method and call it every time we need to test for NFC, as shown in the following code:

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

  if (hasNfc()) {
    Toast.makeText(this, "NFC is available.", Toast.LENGTH_LONG).show();
  } else {
    Toast.makeText(this, "NFC is not available on this device. This application may not work correctly.", Toast.LENGTH_LONG).show();
  }
}

boolean hasNfc() {
  boolean hasFeature = getPackageManager().hasSystemFeature(PackageManager.FEATURE_NFC);
  boolean isEnabled = NfcAdapter.getDefaultAdapter(this).isEnabled();
  
  return hasFeature && isEnabled;
}

The following are the settings required for this recipe:

We are going to download, extract, and verify the Open NFC files that are needed to get our virtual test environment up and running, as shown in the following steps:

We are going to download, extract, and verify the files used to connect the AVD to the NFC Simulator that allows us to test the NFC application without a physical NFC-enabled device with the following steps:

The following are the settings required for this recipe:

We are going to configure the previously downloaded Open NFC plugin into our Android SKD installation as follows:

The add-ons folder in Open NFC Android Edition contains a modified image of the Android system. This modified image contains the simulator for the NFC controller.

The following are the settings required for this recipe:

We are going to use the Android Virtual Device Manager tool to create a device capable of simulating the NFC feature as follows:

When we created the AVD, its target was the modified Android system image; so, when the AVD starts, it also starts the NFC Controller Simulator.

By default, the AVD is configured for the MicroRead controller and NFC is not enabled. We needed to change the configuration to simulator. So, we set the 10.0.2.2 IP address, which is a special alias that represents our machine, and then finally enable NFC.

If you have a slower/older PC, or don't like to wait an infinite amount of time for the AVD to start, or you simply do not like the native simulator, there is a pretty neat alternative. Open NFC provides a VirtualBox appliance, which allows us to run Android in a virtual machine. It's a much faster and smoother alternative, and no extra configuration is needed.

We need to download an open source virtualization software and create a working Android virtual machine as follows:

The following are the settings required for this recipe:

We are going to configure the Connection Center tool properly to recognize our virtual device as follows:

Since our AVD and our PC are two different machines even though the AVD is running on our PC, we need to "tell" the Connection Center tool to allow incoming and outgoing connections from other machines. This way, our AVD is able to connect to the Connection Center tool and vice versa.

The following are the settings required for this recipe:

We'll run everything and perform a simple test to make sure everything works properly before we start our first application:

The Connection Center tool is the first to be started. It listens for connection requests; so, when the Simulator and the AVD start, they will try to connect to a listening server. If no listener is running, nothing happens.

In the Trace Server, we can see what's happening in the communication between the devices. The sent and received messages and communications errors can be found here.

In the Simulator, we can easily see when a device is connected by looking at the top-right box. Here, we find a lot of information such as the communication standard supported by the device, represented by the orange circles, and the standard used in the last communication, represented by the green circles. The Simulator tool provides many other features such as creating custom tags. There is a detailed manual on this in the Open NFC SDK Edition Core folder.