Home | History | Annotate | Download | only in list 
      1 /*
      2  * Copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.contacts.list;
     18 
     19 import android.app.ActionBar;
     20 import android.app.Activity;
     21 import android.app.LoaderManager.LoaderCallbacks;
     22 import android.content.AsyncTaskLoader;
     23 import android.content.Context;
     24 import android.content.Intent;
     25 import android.content.Loader;
     26 import android.graphics.drawable.Drawable;
     27 import android.os.Bundle;
     28 import android.util.Log;
     29 import android.view.LayoutInflater;
     30 import android.view.MenuItem;
     31 import android.view.View;
     32 import android.view.ViewGroup;
     33 import android.widget.AdapterView;
     34 import android.widget.BaseAdapter;
     35 import android.widget.ListView;
     36 
     37 import com.android.contacts.ContactsActivity;
     38 import com.android.contacts.R;
     39 import com.android.contacts.model.AccountTypeManager;
     40 import com.android.contacts.model.account.AccountType;
     41 import com.android.contacts.model.account.AccountWithDataSet;
     42 import com.google.common.collect.Lists;
     43 
     44 import java.util.ArrayList;
     45 import java.util.List;
     46 
     47 /**
     48  * Shows a list of all available accounts, letting the user select under which account to view
     49  * contacts.
     50  */
     51 public class AccountFilterActivity extends ContactsActivity
     52         implements AdapterView.OnItemClickListener {
     53 
     54     private static final String TAG = AccountFilterActivity.class.getSimpleName();
     55 
     56     private static final int SUBACTIVITY_CUSTOMIZE_FILTER = 0;
     57 
     58     public static final String KEY_EXTRA_CONTACT_LIST_FILTER = "contactListFilter";
     59     public static final String KEY_EXTRA_CURRENT_FILTER = "currentFilter";
     60 
     61     private static final int FILTER_LOADER_ID = 0;
     62 
     63     private ListView mListView;
     64 
     65     private ContactListFilter mCurrentFilter;
     66 
     67     @Override
     68     protected void onCreate(Bundle icicle) {
     69         super.onCreate(icicle);
     70         setContentView(R.layout.contact_list_filter);
     71 
     72         mListView = (ListView) findViewById(android.R.id.list);
     73         mListView.setOnItemClickListener(this);
     74 
     75         ActionBar actionBar = getActionBar();
     76         if (actionBar != null) {
     77             actionBar.setDisplayHomeAsUpEnabled(true);
     78         }
     79 
     80         mCurrentFilter = getIntent().getParcelableExtra(KEY_EXTRA_CURRENT_FILTER);
     81 
     82         getLoaderManager().initLoader(FILTER_LOADER_ID, null, new MyLoaderCallbacks());
     83     }
     84 
     85     private static class FilterLoader extends AsyncTaskLoader<List<ContactListFilter>> {
     86         private Context mContext;
     87 
     88         public FilterLoader(Context context) {
     89             super(context);
     90             mContext = context;
     91         }
     92 
     93         @Override
     94         public List<ContactListFilter> loadInBackground() {
     95             return loadAccountFilters(mContext);
     96         }
     97 
     98         @Override
     99         protected void onStartLoading() {
    100             forceLoad();
    101         }
    102 
    103         @Override
    104         protected void onStopLoading() {
    105             cancelLoad();
    106         }
    107 
    108         @Override
    109         protected void onReset() {
    110             onStopLoading();
    111         }
    112     }
    113 
    114     private static List<ContactListFilter> loadAccountFilters(Context context) {
    115         final ArrayList<ContactListFilter> result = Lists.newArrayList();
    116         final ArrayList<ContactListFilter> accountFilters = Lists.newArrayList();
    117         final AccountTypeManager accountTypes = AccountTypeManager.getInstance(context);
    118         List<AccountWithDataSet> accounts = accountTypes.getAccounts(false);
    119         for (AccountWithDataSet account : accounts) {
    120             AccountType accountType = accountTypes.getAccountType(account.type, account.dataSet);
    121             if (accountType.isExtension() && !account.hasData(context)) {
    122                 // Hide extensions with no raw_contacts.
    123                 continue;
    124             }
    125             Drawable icon = accountType != null ? accountType.getDisplayIcon(context) : null;
    126             accountFilters.add(ContactListFilter.createAccountFilter(
    127                     account.type, account.name, account.dataSet, icon));
    128         }
    129 
    130         // Always show "All", even when there's no accounts.  (We may have local contacts)
    131         result.add(ContactListFilter.createFilterWithType(
    132                 ContactListFilter.FILTER_TYPE_ALL_ACCOUNTS));
    133 
    134         final int count = accountFilters.size();
    135         if (count >= 1) {
    136             // If we only have one account, don't show it as "account", instead show it as "all"
    137             if (count > 1) {
    138                 result.addAll(accountFilters);
    139             }
    140             result.add(ContactListFilter.createFilterWithType(
    141                     ContactListFilter.FILTER_TYPE_CUSTOM));
    142         }
    143         return result;
    144     }
    145 
    146     private class MyLoaderCallbacks implements LoaderCallbacks<List<ContactListFilter>> {
    147         @Override
    148         public Loader<List<ContactListFilter>> onCreateLoader(int id, Bundle args) {
    149             return new FilterLoader(AccountFilterActivity.this);
    150         }
    151 
    152         @Override
    153         public void onLoadFinished(
    154                 Loader<List<ContactListFilter>> loader, List<ContactListFilter> data) {
    155             if (data == null) { // Just in case...
    156                 Log.e(TAG, "Failed to load filters");
    157                 return;
    158             }
    159             mListView.setAdapter(
    160                     new FilterListAdapter(AccountFilterActivity.this, data, mCurrentFilter));
    161         }
    162 
    163         @Override
    164         public void onLoaderReset(Loader<List<ContactListFilter>> loader) {
    165         }
    166     }
    167 
    168     @Override
    169     public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
    170         final ContactListFilter filter = (ContactListFilter) view.getTag();
    171         if (filter == null) return; // Just in case
    172         if (filter.filterType == ContactListFilter.FILTER_TYPE_CUSTOM) {
    173             final Intent intent = new Intent(this,
    174                     CustomContactListFilterActivity.class);
    175             startActivityForResult(intent, SUBACTIVITY_CUSTOMIZE_FILTER);
    176         } else {
    177             final Intent intent = new Intent();
    178             intent.putExtra(KEY_EXTRA_CONTACT_LIST_FILTER, filter);
    179             setResult(Activity.RESULT_OK, intent);
    180             finish();
    181         }
    182     }
    183 
    184     @Override
    185     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    186         if (resultCode != Activity.RESULT_OK) {
    187             return;
    188         }
    189 
    190         switch (requestCode) {
    191             case SUBACTIVITY_CUSTOMIZE_FILTER: {
    192                 final Intent intent = new Intent();
    193                 ContactListFilter filter = ContactListFilter.createFilterWithType(
    194                         ContactListFilter.FILTER_TYPE_CUSTOM);
    195                 intent.putExtra(KEY_EXTRA_CONTACT_LIST_FILTER, filter);
    196                 setResult(Activity.RESULT_OK, intent);
    197                 finish();
    198                 break;
    199             }
    200         }
    201     }
    202 
    203     private static class FilterListAdapter extends BaseAdapter {
    204         private final List<ContactListFilter> mFilters;
    205         private final LayoutInflater mLayoutInflater;
    206         private final AccountTypeManager mAccountTypes;
    207         private final ContactListFilter mCurrentFilter;
    208 
    209         public FilterListAdapter(
    210                 Context context, List<ContactListFilter> filters, ContactListFilter current) {
    211             mLayoutInflater = (LayoutInflater) context.getSystemService
    212                     (Context.LAYOUT_INFLATER_SERVICE);
    213             mFilters = filters;
    214             mCurrentFilter = current;
    215             mAccountTypes = AccountTypeManager.getInstance(context);
    216         }
    217 
    218         @Override
    219         public int getCount() {
    220             return mFilters.size();
    221         }
    222 
    223         @Override
    224         public long getItemId(int position) {
    225             return position;
    226         }
    227 
    228         @Override
    229         public ContactListFilter getItem(int position) {
    230             return mFilters.get(position);
    231         }
    232 
    233         public View getView(int position, View convertView, ViewGroup parent) {
    234             final ContactListFilterView view;
    235             if (convertView != null) {
    236                 view = (ContactListFilterView) convertView;
    237             } else {
    238                 view = (ContactListFilterView) mLayoutInflater.inflate(
    239                         R.layout.contact_list_filter_item, parent, false);
    240             }
    241             view.setSingleAccount(mFilters.size() == 1);
    242             final ContactListFilter filter = mFilters.get(position);
    243             view.setContactListFilter(filter);
    244             view.bindView(mAccountTypes);
    245             view.setTag(filter);
    246             view.setActivated(filter.equals(mCurrentFilter));
    247             return view;
    248         }
    249     }
    250 
    251     @Override
    252     public boolean onOptionsItemSelected(MenuItem item) {
    253         switch (item.getItemId()) {
    254             case android.R.id.home:
    255                 // We have two logical "up" Activities: People and Phone.
    256                 // Instead of having one static "up" direction, behave like back as an
    257                 // exceptional case.
    258                 onBackPressed();
    259                 return true;
    260             default:
    261                 break;
    262         }
    263         return super.onOptionsItemSelected(item);
    264     }
    265 }
    266