Android navigation drawer – Account picker

This post describes how to create a navigation drawer with account picker. Android navigation drawer is a new UI pattern introduced in the last I/O. The android navigation drawer is esentially a layer that appears from left to right in the left side of the screen. I want to explain here how to add an account picker to the android navigation drawer.To do it I will use the new Google Service API with Drive SDK mixing them in order to achieve this goal. If you look at Google Drive App you will notice that you can choose your account directly from the left drawer instead of picking it from the settings. In this post, I will show how we can get the folder in our Google drive account selecting it from the left navigation drawer.

Set up the android navigation drawer layout

I won’t give into the details how to use navigation drawer because there are already too many docs talking about it, so this post assumes you are already familiar with this pattern. If you want to know more you can give a look at “Navigation Drawer”. Let’s setup our layout first, we need:

  • A spinner to select our account
  • The navigation drawer items

As we know already the drawer must be the first element in our layout so we have


<FrameLayout android:id="@+id/content_frame"


<TextView android:layout_width="wrap_content"




At line 7 we introduce a FrameLayout in order to handle the UI content dynamically. Instead of using the ListView directly after the FrameLayout (as in the official doc), we introduce a linear layout (line 12) to hold the spinner (line 25) and the menu items. The spinner will be populated with the active user accounts so that when user activate the navigation drawer he will find the account picker too.

Account picker: Populate the spinner with accounts

The next step handling android navigation drawer is creating the account picker so that the user can choose the account to use. To do it we populate the spinner with the active account configured on the smartphone. We use the AccountManager to get the list of the accounts:

[java]AccountManager accMgr = AccountManager.get(this);

Account[] accountList = accMgr.getAccounts();
final String[] accountNames = new String[accountList.length + 1];
int i=1;
accountNames[0] = getResources().getString(R.string.infospinner);

for (Account account : accountList) {
String name =;
accountNames[i++] = name;

Once we have our account list, we have simply to define a new adapter so that the spinner can be populated.

[java]ArrayAdapter<String> adp = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, accountNames);

User account selection

Once we have our account list inside the navigation drawer, we have to  handle the user account selection. To do that we have to override onItemSelected, so that we can set up the right process to require the authorization if needed and set up Drive API correctly. So we have:

public void onItemSelected(AdapterView<?> parent, View view,
int position, long id) {
System.out.println("Pos ["+position+"]");
if (position == 0)
return ;

String currentAccount = accountNames[position];
credential = GoogleAccountCredential.usingOAuth2(MainActivity.this, DriveScopes.DRIVE);
service = getDriveService(credential);
AsyncAuth auth = new AsyncAuth();

At line 8 we select the account chosen. Then we save the credential info chosen (line 9) by the user and start the async process to retrieve the user folder (line 12,13).

Authorization and Google Drive Access

Now we want to access to the Google Drive data and retrieve all the folder in the root directory. We know that to do it we have to be authenticated and authorized and this process is made by two different steps:

  • Choose the account
  • Authorize the account

The first step is already done when we select our account using the spinner (see above), so we have to focus on the second step (the authorization). The first thing we have to do is trying to access to the drive data so that we can know if we are already authorized or we need an authorization. The process to access to the remote drive data uses an HTTP connection so we can’t handle it in our main thread, so that we have to create an async process using AsyncTask.

[java]private class AsyncAuth extends AsyncTask<String, Void, List<File>> {

protected List<File> doInBackground(String… params) {
List<File> fileList = new ArrayList<File>();
try {
Files.List request = service.files().list().setQ("mimeType = ‘" + MIME_FOLDER + "’");

FileList files = request.execute();
fileList = files.getItems();

catch(UserRecoverableAuthIOException e) {
startActivityForResult(e.getIntent(), REQUEST_AUTHORIZATION);
} catch (IOException e1) {

return fileList;


As we can see, we simply try to retrieve user folder (line 7-10) and we catch UserRecoverableAuthIOException (line 13) to get informed if we need to be authorized. If we have to be authorized then we start a new Activity (line 14) asking the authorization request to the user.


Now we have to handle the authorization request result so we implement onActivityResult in our main activity in this way:

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (requestCode) {
System.out.println("Auth request");
if (resultCode == Activity.RESULT_OK) {
AsyncAuth auth = new AsyncAuth();


At line 6 if we have a positive result (RESULT_OK) then we start again the async process to retrieve user folders.

Beautify the code

By now we haven’t still used the FrameLayout, so it is time to use it. As we said at the beginning this frame is used to display some content in the UI. We can change this content dynamically using Fragments. We want to show a “wait” info while we are accessing to the user drive account and then the folder retrieved. To do it we need simply two simple Fragment:

  • WaitFragment that shows the wait symbol while we access to the drive
  • ListFragment that shows the folder list

I won’t go into the details because they’re very simply I want to underline how to change the content in the FrameLayout. If we come back to our AsyncAuth we can notice it is implemented just the doBackgroud method. We have two other methods to exploit in this way:

protected void onPreExecute() {
WaitFragment wf = new WaitFragment();

FragmentManager manager = MainActivity.this.getFragmentManager();
FragmentTransaction trans = manager.beginTransaction();
trans.replace(, wf);

This fragment is shown at the beginning informing the user to wait, and the second:

protected void onPostExecute(List<File> result) {
FragmentManager manager = MainActivity.this.getFragmentManager();
FragmentTransaction trans = manager.beginTransaction();

ListFragment lf = new ListFragment();
List<String> itemList = new ArrayList<String>();
for (File f : result) {

trans.replace(, lf);


We simply populate the listview adapter with the folder names.

Source code availabe at github

    1. Haider August 19, 2013
    2. survivingwithandroid August 19, 2013
    3. Haider August 20, 2013
    4. Haider August 22, 2013
    5. Anonymous November 7, 2014

    Add Your Comment