src/com/android/providers/im/LandingPage.java

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.providers.im;

import android.app.ListActivity;
import android.app.ActivityManagerNative;
import android.app.ActivityThread;
import android.app.Application;
import android.content.ContentUris;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.database.Cursor;
import android.im.IImPlugin;
import android.im.ImPluginConsts;
import android.im.BrandingResourceIDs;
import android.net.Uri;
import android.os.Bundle;
import android.os.RemoteException;
import android.os.IBinder;
import android.provider.Im;
import android.util.Log;
import android.util.AttributeSet;
import android.view.ContextMenu;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.LayoutInflater;
import android.view.ContextMenu.ContextMenuInfo;
import android.widget.AdapterView;
import android.widget.ListView;
import android.widget.CursorAdapter;

import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;

import com.android.providers.im.R;

import dalvik.system.PathClassLoader;

public class LandingPage extends ListActivity implements View.OnCreateContextMenuListener {
    private static final String TAG = "IM";
    private final static boolean LOCAL_DEBUG = false;

    private static final int ID_SIGN_IN = Menu.FIRST + 1;
    private static final int ID_SIGN_OUT = Menu.FIRST + 2;
    private static final int ID_EDIT_ACCOUNT = Menu.FIRST + 3;
    private static final int ID_REMOVE_ACCOUNT = Menu.FIRST + 4;
    private static final int ID_SIGN_OUT_ALL = Menu.FIRST + 5;
    private static final int ID_ADD_ACCOUNT = Menu.FIRST + 6;
    private static final int ID_VIEW_CONTACT_LIST = Menu.FIRST + 7;
    private static final int ID_SETTINGS = Menu.FIRST + 8;

    private ProviderAdapter mAdapter;
    private Cursor mProviderCursor;

    private static final String[] PROVIDER_PROJECTION = {
            Im.Provider._ID,
            Im.Provider.NAME,
            Im.Provider.FULLNAME,
            Im.Provider.CATEGORY,
            Im.Provider.ACTIVE_ACCOUNT_ID,
            Im.Provider.ACTIVE_ACCOUNT_USERNAME,
            Im.Provider.ACTIVE_ACCOUNT_PW,
            Im.Provider.ACTIVE_ACCOUNT_LOCKED,
            Im.Provider.ACCOUNT_PRESENCE_STATUS,
            Im.Provider.ACCOUNT_CONNECTION_STATUS,
    };

    private static final int PROVIDER_ID_COLUMN = 0;
    private static final int PROVIDER_NAME_COLUMN = 1;
    private static final int PROVIDER_FULLNAME_COLUMN = 2;
    private static final int PROVIDER_CATEGORY_COLUMN = 3;
    private static final int ACTIVE_ACCOUNT_ID_COLUMN = 4;
    private static final int ACTIVE_ACCOUNT_USERNAME_COLUMN = 5;
    private static final int ACTIVE_ACCOUNT_PW_COLUMN = 6;
    private static final int ACTIVE_ACCOUNT_LOCKED = 7;
    private static final int ACCOUNT_PRESENCE_STATUS = 8;
    private static final int ACCOUNT_CONNECTION_STATUS = 9;

    private static final String PROVIDER_SELECTION = "providers.name!=?";

    private HashMap<String, PluginInfo> mProviderToPluginMap;
    private HashMap<Long, PluginInfo> mAccountToPluginMap;
    private HashMap<Long, BrandingResources> mBrandingResources;
    private BrandingResources mDefaultBrandingResources;

    private String[] mProviderSelectionArgs = new String[1];

    public class PluginInfo {
        public IImPlugin mPlugin;
        /**
         * The name of the package that the plugin is in.
         */
        public String mPackageName;

        /**
         * The name of the class that implements {@link @ImFrontDoorPlugin} in this plugin.
         */
        public String mClassName;

        /**
         * The full path to the location of the package that the plugin is in.
         */
        public String mSrcPath;

        public PluginInfo(IImPlugin plugin, String packageName, String className,
                String srcPath) {
            mPackageName = packageName;
            mClassName = className;
            mSrcPath = srcPath;
            mPlugin = plugin;
        }
    };

    @Override
    protected void onCreate(Bundle icicle) {
        super.onCreate(icicle);

        setTitle(R.string.landing_page_title);

        if (!loadPlugins()) {
            Log.e(TAG, "[onCreate] load plugin failed, no plugin found!");
            finish();
            return;
        }

        startPlugins();

        // get everything except for Google Talk.
        mProviderSelectionArgs[0] = Im.ProviderNames.GTALK;
        mProviderCursor = managedQuery(Im.Provider.CONTENT_URI_WITH_ACCOUNT,
                PROVIDER_PROJECTION,
                PROVIDER_SELECTION /* selection */,
                mProviderSelectionArgs /* selection args */,
                Im.Provider.DEFAULT_SORT_ORDER);
        mAdapter = new ProviderAdapter(this, mProviderCursor);
        setListAdapter(mAdapter);
        
        rebuildAccountToPluginMap();

        mBrandingResources = new HashMap<Long, BrandingResources>();
        loadDefaultBrandingRes();
        loadBrandingResources();

        registerForContextMenu(getListView());
    }

    @Override
    protected void onRestart() {
        super.onRestart();

        // refresh the accountToPlugin map after mProviderCursor is requeried
        if (!rebuildAccountToPluginMap()) {
            Log.w(TAG, "[onRestart] rebuiltAccountToPluginMap failed, reload plugins...");
            
            if (!loadPlugins()) {
                Log.e(TAG, "[onRestart] load plugin failed, no plugin found!");
                finish();
                return;
            }
            rebuildAccountToPluginMap();
        }

        startPlugins();
    }

    @Override
    protected void onStop() {
        super.onStop();
        stopPlugins();
    }

    private boolean loadPlugins() {
        mProviderToPluginMap = new HashMap<String, PluginInfo>();
        
        PackageManager pm = getPackageManager();
        List<ResolveInfo> plugins = pm.queryIntentServices(
                new Intent(ImPluginConsts.PLUGIN_ACTION_NAME),
                PackageManager.GET_META_DATA);
        for (ResolveInfo info : plugins) {
            if (Log.isLoggable(TAG, Log.DEBUG)) log("loadPlugins: found plugin " + info);

            ServiceInfo serviceInfo = info.serviceInfo;
            if (serviceInfo == null) {
                Log.e(TAG, "Ignore bad IM frontdoor plugin: " + info);
                continue;
            }

            IImPlugin plugin = null;

            // Load the plug-in directly from the apk instead of binding the service
            // and calling through the IPC binder API. It's more effective in this way
            // and we can avoid the async behaviors of binding service.
            PathClassLoader classLoader = new PathClassLoader(serviceInfo.applicationInfo.sourceDir,
                    getClassLoader());
            try {
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    log("loadPlugin: load class " + serviceInfo.name);
                }
                Class cls = classLoader.loadClass(serviceInfo.name);
                Object newInstance = cls.newInstance();
                Method m;

                // call "attach" method, so the plugin will get initialized with the proper context
                m = cls.getMethod("attach", Context.class, ActivityThread.class, String.class,
                        IBinder.class, Application.class, Object.class);
                m.invoke(newInstance,
                        new Object[] {this, null, serviceInfo.name, null, getApplication(),
                                ActivityManagerNative.getDefault()});

                // call "bind" to get the plugin object
                m = cls.getMethod("onBind", Intent.class);
                plugin = (IImPlugin)m.invoke(newInstance, new Object[]{null});
            } catch (ClassNotFoundException e) {
                Log.e(TAG, "Failed load the plugin", e);
            } catch (IllegalAccessException e) {
                Log.e(TAG, "Failed load the plugin", e);
            } catch (InstantiationException e) {
                Log.e(TAG, "Failed load the plugin", e);
            } catch (SecurityException e) {
                Log.e(TAG, "Failed load the plugin", e);
            } catch (NoSuchMethodException e) {
                Log.e(TAG, "Failed load the plugin", e);
            } catch (IllegalArgumentException e) {
                Log.e(TAG, "Failed load the plugin", e);
            } catch (InvocationTargetException e) {
                Log.e(TAG, "Failed load the plugin", e);
            }

            if (plugin != null) {
                if (Log.isLoggable(TAG, Log.DEBUG)) log("loadPlugin: plugin " + plugin + " loaded");
                ArrayList<String> providers = getSupportedProviders(plugin);

                if (providers == null || providers.size() == 0) {
                    Log.e(TAG, "Ignore bad IM frontdoor plugin: " + info + ". No providers found");
                    continue;
                }

                PluginInfo pluginInfo = new PluginInfo(plugin,
                        serviceInfo.packageName,
                        serviceInfo.name,
                        serviceInfo.applicationInfo.sourceDir);

                for (String providerName : providers) {
                    mProviderToPluginMap.put(providerName, pluginInfo);
                }
            }
        }

        return mProviderToPluginMap.size() > 0;
    }

    private void startPlugins() {
        Iterator<PluginInfo> itor = mProviderToPluginMap.values().iterator();

        while (itor.hasNext()) {
            PluginInfo pluginInfo = itor.next();
            try {
                pluginInfo.mPlugin.onStart();
            } catch (RemoteException e) {
                Log.e(TAG, "Could not start plugin " + pluginInfo.mPackageName, e);
            }
        }
    }

    private void stopPlugins() {
        Iterator<PluginInfo> itor = mProviderToPluginMap.values().iterator();

        while (itor.hasNext()) {
            PluginInfo pluginInfo = itor.next();
            try {
                pluginInfo.mPlugin.onStop();
            } catch (RemoteException e) {
                Log.e(TAG, "Could not stop plugin " + pluginInfo.mPackageName, e);
            }
        }
    }

    private ArrayList<String> getSupportedProviders(IImPlugin plugin) {
        ArrayList<String> providers = null;

        try {
            providers = (ArrayList<String>) plugin.getSupportedProviders();
        } catch (RemoteException ex) {
            Log.e(TAG, "getSupportedProviders caught ", ex);
        }

        return providers;
    }

    private void loadDefaultBrandingRes() {
        HashMap<Integer, Integer> resMapping = new HashMap<Integer, Integer>();

        resMapping.put(BrandingResourceIDs.DRAWABLE_LOGO, R.drawable.imlogo_s);
        resMapping.put(BrandingResourceIDs.DRAWABLE_PRESENCE_ONLINE,
                android.R.drawable.presence_online);
        resMapping.put(BrandingResourceIDs.DRAWABLE_PRESENCE_AWAY,
                android.R.drawable.presence_away);
        resMapping.put(BrandingResourceIDs.DRAWABLE_PRESENCE_BUSY,
                android.R.drawable.presence_busy);
        resMapping.put(BrandingResourceIDs.DRAWABLE_PRESENCE_INVISIBLE,
                android.R.drawable.presence_invisible);
        resMapping.put(BrandingResourceIDs.DRAWABLE_PRESENCE_OFFLINE,
                android.R.drawable.presence_offline);
        resMapping.put(BrandingResourceIDs.STRING_MENU_CONTACT_LIST,
                R.string.menu_view_contact_list);

        mDefaultBrandingResources = new BrandingResources(this, resMapping, null /* default res */);
    }

    private void loadBrandingResources() {
        mProviderCursor.moveToFirst();
        do {
            long providerId = mProviderCursor.getLong(PROVIDER_ID_COLUMN);
            String providerName = mProviderCursor.getString(PROVIDER_NAME_COLUMN);
            PluginInfo pluginInfo = mProviderToPluginMap.get(providerName);

            if (pluginInfo == null) {
                Log.w(TAG, "[LandingPage] loadBrandingResources: no plugin found for " + providerName);
                continue;
            }
            
            if (!mBrandingResources.containsKey(providerId)) {
                BrandingResources res = new BrandingResources(this, pluginInfo, providerName,
                        mDefaultBrandingResources);
                mBrandingResources.put(providerId, res);
            }
        } while (mProviderCursor.moveToNext()) ;
    }

    public BrandingResources getBrandingResource(long providerId) {
        BrandingResources res = mBrandingResources.get(providerId);
        return res == null ? mDefaultBrandingResources : res;
    }

    private boolean rebuildAccountToPluginMap() {
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            log("rebuildAccountToPluginMap");
        }
        
        if (mAccountToPluginMap != null) {
            mAccountToPluginMap.clear();
        }
        
        mAccountToPluginMap = new HashMap<Long, PluginInfo>();

        mProviderCursor.moveToFirst();

        boolean retVal = true;

        do {
            long accountId = mProviderCursor.getLong(ACTIVE_ACCOUNT_ID_COLUMN);

            if (accountId == 0) {
                continue;
            }
            
            String name = mProviderCursor.getString(PROVIDER_NAME_COLUMN);
            PluginInfo pluginInfo = mProviderToPluginMap.get(name);
            if (pluginInfo != null) {
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    log("rebuildAccountToPluginMap: add plugin for acct=" + accountId + ", provider=" + name);
                }
                mAccountToPluginMap.put(accountId, pluginInfo);
            } else {
                Log.w(TAG, "[LandingPage] no plugin found for " + name);
                retVal = false;
            }
        } while (mProviderCursor.moveToNext()) ;

        return retVal;
    }

    private void signIn(long accountId) {
        if (accountId == 0) {
            Log.w(TAG, "signIn: account id is 0, bail");
            return;
        }

        boolean isAccountEditible = mProviderCursor.getInt(ACTIVE_ACCOUNT_LOCKED) == 0;
        if (isAccountEditible && mProviderCursor.isNull(ACTIVE_ACCOUNT_PW_COLUMN)) {
            // no password, edit the account
            if (Log.isLoggable(TAG, Log.DEBUG)) log("no pw for account " + accountId);
            Intent intent = getEditAccountIntent();
            startActivity(intent);
            return;
        }


        PluginInfo pluginInfo = mAccountToPluginMap.get(accountId);
        if (pluginInfo == null) {
            Log.e(TAG, "signIn: cannot find plugin for account " + accountId);
            return;
        }

        try {
            if (Log.isLoggable(TAG, Log.DEBUG)) log("sign in for account " + accountId);
            pluginInfo.mPlugin.signIn(accountId);
        } catch (RemoteException ex) {
            Log.e(TAG, "signIn failed", ex);
        }
    }

    boolean isSigningIn(Cursor cursor) {
        int connectionStatus = cursor.getInt(ACCOUNT_CONNECTION_STATUS);
        return connectionStatus == Im.ConnectionStatus.CONNECTING;
    }

    boolean isSignedIn(Cursor cursor) {
        int connectionStatus = cursor.getInt(ACCOUNT_CONNECTION_STATUS);
        return connectionStatus == Im.ConnectionStatus.ONLINE;
    }

    private boolean allAccountsSignedOut() {
        mProviderCursor.moveToFirst();
        do {
            if (isSignedIn(mProviderCursor)) {
                return false;
            }
        } while (mProviderCursor.moveToNext()) ;

        return true;
    }

    private void signoutAll() {
        do {
            long accountId = mProviderCursor.getLong(ACTIVE_ACCOUNT_ID_COLUMN);
            signOut(accountId);
        } while (mProviderCursor.moveToNext()) ;
    }

    private void signOut(long accountId) {
        if (accountId == 0) {
            Log.w(TAG, "signOut: account id is 0, bail");
            return;
        }

        PluginInfo pluginInfo = mAccountToPluginMap.get(accountId);
        if (pluginInfo == null) {
            Log.e(TAG, "signOut: cannot find plugin for account " + accountId);
            return;
        }

        try {
            if (Log.isLoggable(TAG, Log.DEBUG)) log("sign out for account " + accountId);
            pluginInfo.mPlugin.signOut(accountId);
        } catch (RemoteException ex) {
            Log.e(TAG, "signOut failed", ex);
        }
    }

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        super.onPrepareOptionsMenu(menu);
        menu.findItem(ID_SIGN_OUT_ALL).setVisible(!allAccountsSignedOut());
        return true;
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        menu.add(0, ID_SIGN_OUT_ALL, 0, R.string.menu_sign_out_all)
                .setIcon(android.R.drawable.ic_menu_close_clear_cancel);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case ID_SIGN_OUT_ALL:
                signoutAll();
                return true;
        }
        return super.onOptionsItemSelected(item);
    }

    @Override
    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
        AdapterView.AdapterContextMenuInfo info;
        try {
            info = (AdapterView.AdapterContextMenuInfo) menuInfo;
        } catch (ClassCastException e) {
            Log.e(TAG, "bad menuInfo", e);
            return;
        }

        Cursor providerCursor = (Cursor) getListAdapter().getItem(info.position);
        menu.setHeaderTitle(providerCursor.getString(PROVIDER_FULLNAME_COLUMN));

        if (providerCursor.isNull(ACTIVE_ACCOUNT_ID_COLUMN)) {
            menu.add(0, ID_ADD_ACCOUNT, 0, R.string.menu_add_account);
            return;
        }

        long providerId = providerCursor.getLong(PROVIDER_ID_COLUMN);
        boolean isLoggingIn = isSigningIn(providerCursor);
        boolean isLoggedIn = isSignedIn(providerCursor);

        if (!isLoggedIn) {
            menu.add(0, ID_SIGN_IN, 0, R.string.sign_in).setIcon(com.android.internal.R.drawable.ic_menu_login);
        } else {
            BrandingResources brandingRes = getBrandingResource(providerId);
            menu.add(0, ID_VIEW_CONTACT_LIST, 0,
                    brandingRes.getString(BrandingResourceIDs.STRING_MENU_CONTACT_LIST));
            menu.add(0, ID_SIGN_OUT, 0, R.string.menu_sign_out)
                .setIcon(android.R.drawable.ic_menu_close_clear_cancel);
        }

        boolean isAccountEditible = providerCursor.getInt(ACTIVE_ACCOUNT_LOCKED) == 0;
        if (isAccountEditible && !isLoggingIn && !isLoggedIn) {
            menu.add(0, ID_EDIT_ACCOUNT, 0, R.string.menu_edit_account)
                .setIcon(android.R.drawable.ic_menu_edit);
            menu.add(0, ID_REMOVE_ACCOUNT, 0, R.string.menu_remove_account)
                .setIcon(android.R.drawable.ic_menu_delete);
        }

        // always add a settings menu item
        menu.add(0, ID_SETTINGS, 0, R.string.menu_settings);
    }

    @Override
    public boolean onContextItemSelected(MenuItem item) {
        AdapterView.AdapterContextMenuInfo info;
        try {
            info = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
        } catch (ClassCastException e) {
            Log.e(TAG, "bad menuInfo", e);
            return false;
        }
        long providerId = info.id;
        Cursor providerCursor = (Cursor) getListAdapter().getItem(info.position);
        long accountId = providerCursor.getLong(ACTIVE_ACCOUNT_ID_COLUMN);

        switch (item.getItemId()) {
            case ID_EDIT_ACCOUNT:
            {
                startActivity(getEditAccountIntent());
                return true;
            }

            case ID_REMOVE_ACCOUNT:
            {
                Uri accountUri = ContentUris.withAppendedId(Im.Account.CONTENT_URI, accountId);
                getContentResolver().delete(accountUri, null, null);
                // Requery the cursor to force refreshing screen
                providerCursor.requery();
                return true;
            }

            case ID_VIEW_CONTACT_LIST:
            {
                Intent intent = getViewContactsIntent();
                startActivity(intent);
                return true;
            }
            case ID_ADD_ACCOUNT:
            {
                startActivity(getCreateAccountIntent());
                return true;
            }

            case ID_SIGN_IN:
            {
                signIn(accountId);
                return true;
            }

            case ID_SIGN_OUT:
            {
                // TODO: progress bar
                signOut(accountId);
                return true;
            }

            case ID_SETTINGS:
            {
                Intent intent = new Intent(Intent.ACTION_VIEW, Im.ProviderSettings.CONTENT_URI);
                intent.addCategory(getProviderCategory(providerCursor));
                intent.putExtra("providerId", providerId);
                startActivity(intent);
                return true;
            }

        }

        return false;
    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        Intent intent = null;
        mProviderCursor.moveToPosition(position);

        if (mProviderCursor.isNull(ACTIVE_ACCOUNT_ID_COLUMN)) {
            // add account
            intent = getCreateAccountIntent();
        } else {
            int state = mProviderCursor.getInt(ACCOUNT_CONNECTION_STATUS);

            if (state == Im.ConnectionStatus.OFFLINE || state == Im.ConnectionStatus.CONNECTING) {
                boolean isAccountEditible = mProviderCursor.getInt(ACTIVE_ACCOUNT_LOCKED) == 0;
                if (isAccountEditible && mProviderCursor.isNull(ACTIVE_ACCOUNT_PW_COLUMN)) {
                    // no password, edit the account
                    intent = getEditAccountIntent();
                } else {
                    long accountId = mProviderCursor.getLong(ACTIVE_ACCOUNT_ID_COLUMN);
                    signIn(accountId);
                }
            } else {
                intent = getViewContactsIntent();
            }
        }

        if (intent != null) {
            startActivity(intent);
        }
    }

    Intent getCreateAccountIntent() {
        Intent intent = new Intent();
        intent.setAction(Intent.ACTION_INSERT);

        long providerId = mProviderCursor.getLong(PROVIDER_ID_COLUMN);
        intent.setData(ContentUris.withAppendedId(Im.Provider.CONTENT_URI, providerId));
        intent.addCategory(getProviderCategory(mProviderCursor));
        return intent;
    }

    Intent getEditAccountIntent() {
        Intent intent = new Intent(Intent.ACTION_EDIT,
                ContentUris.withAppendedId(Im.Account.CONTENT_URI,
                        mProviderCursor.getLong(ACTIVE_ACCOUNT_ID_COLUMN)));
        intent.addCategory(getProviderCategory(mProviderCursor));
        return intent;
    }

    Intent getViewContactsIntent() {
        Intent intent = new Intent(Intent.ACTION_VIEW);
        intent.setData(Im.Contacts.CONTENT_URI);
        intent.addCategory(getProviderCategory(mProviderCursor));
        intent.putExtra("accountId", mProviderCursor.getLong(ACTIVE_ACCOUNT_ID_COLUMN));
        return intent;
    }

    private String getProviderCategory(Cursor cursor) {
        return cursor.getString(PROVIDER_CATEGORY_COLUMN);
    }

    
    static void log(String msg) {
        Log.d(TAG, "[LandingPage]" + msg);
    }

    private class ProviderListItemFactory implements LayoutInflater.Factory {
        public View onCreateView(String name, Context context, AttributeSet attrs) {
            if (name != null && name.equals(ProviderListItem.class.getName())) {
                return new ProviderListItem(context, LandingPage.this);
            }
            return null;
        }
    }

    private final class ProviderAdapter extends CursorAdapter {
        private LayoutInflater mInflater;

        public ProviderAdapter(Context context, Cursor c) {
            super(context, c);
            mInflater = LayoutInflater.from(context).cloneInContext(context);
            mInflater.setFactory(new ProviderListItemFactory());
        }

        @Override
        public View newView(Context context, Cursor cursor, ViewGroup parent) {
            // create a custom view, so we can manage it ourselves. Mainly, we want to
            // initialize the widget views (by calling getViewById()) in newView() instead of in
            // bindView(), which can be called more often.
            ProviderListItem view = (ProviderListItem) mInflater.inflate(
                    R.layout.account_view, parent, false);
            view.init(cursor);
            return view;
        }

        @Override
        public void bindView(View view, Context context, Cursor cursor) {
            ((ProviderListItem) view).bindView(cursor);
        }
    }

}