Modify the Forcedroid Native App

As you saw earlier, the native Android template app shows a list of contacts or accounts from the user’s Salesforce organization. It’s currently a read-only list built from a simple SOQL SELECT query that is processed through the Mobile SDK REST classes. Let’s add some editing powers by attaching a delete action to the long press gesture. When the user taps and holds a contact name in the list view, your new delete action attempts to delete the associated Salesforce record. If that attempt succeeds, your app permanently removes the row from the Contacts list view in the app. If the request fails, your app tells the user why it failed and reinstates the list view row.

Long click listener implementation is straightforward. Deciding how to create your long click listener class, however, is a little trickier. If you explore the various coding options, the first thing you discover is that you don’t listen for clicks at the list view level. Instead, you listen at the list item level. Luckily, implementing listeners for list items isn’t an onerous task, thanks to the Android OnItemLongClickListener interface. This interface defines a single listener that is attached to the list view and responds to long presses on any item in the list. You create an instance of this class by implementing a public interface within your view class.

The next challenge is to figure out which view class implements the long click listener. With ListView objects, you provide a data object that provides the information that’s displayed in the list. The Mobile SDK template app creates an ArrayAdapter<String> object for that purpose, and then attaches it to the ListView.

listAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, new 
ArrayList<String>());
((ListView) findViewById(R.id.contacts_list)).setAdapter(listAdapter);

But ArrayAdapter<String> is a data object, not a view—right? Yes, and more. The ArrayAdapter on the Contacts list view creates an AdapterView object for each item in the list’s data set. Because these adapter views represent the objects of interest, you use the AdapterView class to implement OnItemLongClickListener. You then associate the listener object with the ListView object, which receives all notifications for its children. This association limits your OnItemLongClickListener to interact only with the items in the template app’s list view. Finally, you implement your delete behavior in the sole interface method.

One final detail to resolve: Where do you place this long click listener code? Mobile SDK gives you the following entry point callback methods:

public abstract void onResume(RestClient client);

@Override
protected void onCreate(Bundle savedInstanceState);

@Override 
public void onResume();

We can eliminate one: onCreate(Bundle savedInstanceState). This method sets up the activity and handles authentication flows before the views are instantiated. The views enter the scene in the onResume() method. This method, then, seems to be the most likely candidate. The onResume(RestClient client) method is called by the superclass at login to capture the authenticated RestClient object—let’s leave that one alone. Therefore, the results are in—add your long click listener code to onResume().

Now we’re almost ready to add Mobile SDK elements. In the onItemLongClick() method, you create a REST request to delete the Salesforce record associated with the row that was tapped. You then send that request to Salesforce. Before digging into the code, review these important points.

public static RestRequest getRequestForDelete(String apiVersion, String objectType, String objectId);

Your MainActivity class issues two REST requests: one for contacts, and another for accounts. Each request contains a SOQL statement. We’re not going to use accounts, so let’s update the Contact records request to return ID values.

1. In Android Studio, open the MainActivity.java file.
2. Find the onFetchContactsClick() method.

   public void onFetchContactsClick(View v) throws UnsupportedEncodingException
   {
      sendRequest("SELECT Name FROM Contact");
   }
   

3. Change the SOQL query to select the Name and Id fields. Be sure to use the camel-case spelling of the ID field name. Field names are case-sensitive.

   public void onFetchContactsClick(View v) throws UnsupportedEncodingException
   {
      sendRequest("SELECT Name, Id FROM Contact");
   }

Now that you’re equipped to receive the ID values in the REST response, where’s the best place to store them? The template app merely copies the Name value for each record into a list view row—it doesn’t cache the ID values. To enable lookups in your long press handler, you must store the IDs in class scope.

RestRequest restRequest = RestRequest.getRequestForQuery(
    ApiVersionStrings.getVersionNumber(this), soql);

Then, it sends the new RestRequest object to Salesforce in the client.sendAsync() call.

client.sendAsync(restRequest, new AsyncRequestCallback() {
    @Override
    public void onSuccess(RestRequest request, final RestResponse result) {
        result.consumeQuietly(); // consume before going back to main thread
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                try {
                    listAdapter.clear();
                    JSONArray records = result.asJSONObject().getJSONArray("records");
                    for (int i = 0; i < records.length(); i++) {
                        listAdapter.add(records.getJSONObject(i).getString("Name"));
                    }
                } catch (Exception e) {
                    onError(e);
                }
            }
        });
    }
 
    @Override
    public void onError(final Exception exception) {
        runOnUiThread(new Runnable() {
        @Override
            public void run() {
                Toast.makeText(MainActivity.this,
                    MainActivity.this.getString(
                        R.string.sf__generic_error, 
                        exception.toString()),
                    Toast.LENGTH_LONG).show();
            }
        });
    }
});

In addition to the RestRequest object, the sendAsync() call requires an implementation of the Mobile SDK AsyncRequestCallback interface. The onSuccess() method of this interface receives the REST response asynchronously through a callback. Your default AsyncRequestCallback implementation handles only the SOQL queries defined in your forcedroid app.

Now you’re prepared to finish the onItemLongClick() method. The basic algorithm is as follows:

1. Get a “request for delete” object by calling an appropriate Mobile SDK RestRequest factory method. All RestRequest methods throw exceptions, so be sure to enclose the call in a try...catch block.
2. Send the “request for delete” object to Salesforce using the generated RestClient object.
3. Handle the REST result in callback methods.

One final bit of cleanup is to remove the Fetch Accounts button. Since the list view is shared between Fetch Contacts and Fetch Accounts, your long press handler applies equally to both. However, this handler is useless for accounts because the ID you use to delete the record only applies to a contact. Alternatively—as “extra credit”—you can apply what you’ve learned and adapt the long press handler to delete both contacts and accounts. For this tutorial, though, let’s remove the accounts-related code.

Delete the following items from the indicated files:

At last, your app is finished and ready to run!

1. In Android Studio, click Run | Run ‘app’.
2. Select a Mobile SDK-compatible emulator or connected device.
3. When the app is running, log in to your Salesforce organization, then click Fetch Contacts to see the list. Tap and hold any item in the list until you see a toast message confirming the long press.

Notice that you get an error response when you try to delete any default contact in the Developer Edition database. These errors occur because each contact that comes pre-packaged in a Developer Edition org is the parent of other records. To prepare for testing, log in to your Developer Edition org and create one or more test contacts that don’t own other records. If the deletion is successful, a message appears to indicate that the record was deleted.

• Using REST APIs
• RestClient Class
• RestRequest Class