nfc/cardemulation/RegisteredAidCache.java

package com.android.nfc.cardemulation;

import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.database.ContentObserver;
import android.net.Uri;
import android.nfc.cardemulation.ApduServiceInfo;
import android.nfc.cardemulation.CardEmulation;
import android.nfc.cardemulation.ApduServiceInfo.AidGroup;
import android.os.Handler;
import android.os.Looper;
import android.os.UserHandle;
import android.provider.Settings;
import android.util.Log;

import com.google.android.collect.Maps;

import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

public class RegisteredAidCache implements RegisteredServicesCache.Callback {
    static final String TAG = "RegisteredAidCache";

    static final boolean DBG = false;

    // mAidServices is a tree that maps an AID to a list of handling services
    // on Android. It is only valid for the current user.
    final TreeMap<String, ArrayList<ApduServiceInfo>> mAidToServices =
            new TreeMap<String, ArrayList<ApduServiceInfo>>();

    // mAidCache is a lookup table for quickly mapping an AID to one or
    // more services. It differs from mAidServices in the sense that it
    // has already accounted for defaults, and hence its return value
    // is authoritative for the current set of services and defaults.
    // It is only valid for the current user.
    final HashMap<String, AidResolveInfo> mAidCache =
            Maps.newHashMap();

    final HashMap<String, ComponentName> mCategoryDefaults =
            Maps.newHashMap();

    final class AidResolveInfo {
        List<ApduServiceInfo> services;
        ApduServiceInfo defaultService;
        String aid;
    }

    /**
     * AIDs per category
     */
    public final HashMap<String, Set<String>> mCategoryAids =
            Maps.newHashMap();

    final Handler mHandler = new Handler(Looper.getMainLooper());
    final RegisteredServicesCache mServiceCache;

    final Object mLock = new Object();
    final Context mContext;
    final AidRoutingManager mRoutingManager;
    final SettingsObserver mSettingsObserver;

    ComponentName mNextTapComponent = null;
    boolean mNfcEnabled = false;

    private final class SettingsObserver extends ContentObserver {
        public SettingsObserver(Handler handler) {
            super(handler);
        }

        @Override
        public void onChange(boolean selfChange, Uri uri) {
            super.onChange(selfChange, uri);
            synchronized (mLock) {
                // Do it just for the current user. If it was in fact
                // a change made for another user, we'll sync it down
                // on user switch.
                int currentUser = ActivityManager.getCurrentUser();
                boolean changed = updateFromSettingsLocked(currentUser);
                if (changed) {
                    generateAidCacheLocked();
                    updateRoutingLocked();
                } else {
                    if (DBG) Log.d(TAG, "Not updating aid cache + routing: nothing changed.");
                }
            }
        }
    };

    public RegisteredAidCache(Context context, AidRoutingManager routingManager) {
        mSettingsObserver = new SettingsObserver(mHandler);
        mContext = context;
        mServiceCache = new RegisteredServicesCache(context, this);
        mRoutingManager = routingManager;

        mContext.getContentResolver().registerContentObserver(
                Settings.Secure.getUriFor(Settings.Secure.NFC_PAYMENT_DEFAULT_COMPONENT),
                true, mSettingsObserver, UserHandle.USER_ALL);
        updateFromSettingsLocked(ActivityManager.getCurrentUser());
    }

    public boolean isNextTapOverriden() {
        synchronized (mLock) {
            return mNextTapComponent != null;
        }
    }

    public AidResolveInfo resolveAidPrefix(String aid) {
        synchronized (mLock) {
            char nextAidChar = (char) (aid.charAt(aid.length() - 1) + 1);
            String nextAid = aid.substring(0, aid.length() - 1) + nextAidChar;
            SortedMap<String, ArrayList<ApduServiceInfo>> matches =
                    mAidToServices.subMap(aid, nextAid);
            // The first match is lexicographically closest to what the reader asked;
            if (matches.isEmpty()) {
                return null;
            } else {
                AidResolveInfo resolveInfo = mAidCache.get(matches.firstKey());
                // Let the caller know which AID got selected
                resolveInfo.aid = matches.firstKey();
                return resolveInfo;
            }
        }
    }

    public String getCategoryForAid(String aid) {
        synchronized (mLock) {
            Set<String> paymentAids = mCategoryAids.get(CardEmulation.CATEGORY_PAYMENT);
            if (paymentAids != null && paymentAids.contains(aid)) {
                return CardEmulation.CATEGORY_PAYMENT;
            } else {
                return CardEmulation.CATEGORY_OTHER;
            }
        }
    }

    public boolean isDefaultServiceForAid(int userId, ComponentName service, String aid) {
        AidResolveInfo resolveInfo = null;
        boolean serviceFound = false;
        synchronized (mLock) {
            serviceFound = mServiceCache.hasService(userId, service);
        }
        if (!serviceFound) {
            // If we don't know about this service yet, it may have just been enabled
            // using PackageManager.setComponentEnabledSetting(). The PackageManager
            // broadcasts are delayed by 10 seconds in that scenario, which causes
            // calls to our APIs referencing that service to fail.
            // Hence, update the cache in case we don't know about the service.
            if (DBG) Log.d(TAG, "Didn't find passed in service, invalidating cache.");
            mServiceCache.invalidateCache(userId);
        }
        synchronized (mLock) {
            resolveInfo = mAidCache.get(aid);
        }
        if (resolveInfo.services == null || resolveInfo.services.size() == 0) return false;

        if (resolveInfo.defaultService != null) {
            return service.equals(resolveInfo.defaultService.getComponent());
        } else if (resolveInfo.services.size() == 1) {
            return service.equals(resolveInfo.services.get(0).getComponent());
        } else {
            // More than one service, not the default
            return false;
        }
    }

    public boolean setDefaultServiceForCategory(int userId, ComponentName service,
            String category) {
        if (!CardEmulation.CATEGORY_PAYMENT.equals(category)) {
            Log.e(TAG, "Not allowing defaults for category " + category);
            return false;
        }
        synchronized (mLock) {
            // TODO Not really nice to be writing to Settings.Secure here...
            // ideally we overlay our local changes over whatever is in
            // Settings.Secure
            if (service == null || mServiceCache.hasService(userId, service)) {
                Settings.Secure.putStringForUser(mContext.getContentResolver(),
                        Settings.Secure.NFC_PAYMENT_DEFAULT_COMPONENT,
                        service != null ? service.flattenToString() : null, userId);
            } else {
                Log.e(TAG, "Could not find default service to make default: " + service);
            }
        }
        return true;
    }

    public boolean isDefaultServiceForCategory(int userId, String category,
            ComponentName service) {
        boolean serviceFound = false;
        synchronized (mLock) {
            // If we don't know about this service yet, it may have just been enabled
            // using PackageManager.setComponentEnabledSetting(). The PackageManager
            // broadcasts are delayed by 10 seconds in that scenario, which causes
            // calls to our APIs referencing that service to fail.
            // Hence, update the cache in case we don't know about the service.
            serviceFound = mServiceCache.hasService(userId, service);
        }
        if (!serviceFound) {
            if (DBG) Log.d(TAG, "Didn't find passed in service, invalidating cache.");
            mServiceCache.invalidateCache(userId);
        }
        ComponentName defaultService =
                getDefaultServiceForCategory(userId, category, true);
        return (defaultService != null && defaultService.equals(service));
    }

    ComponentName getDefaultServiceForCategory(int userId, String category,
            boolean validateInstalled) {
        if (!CardEmulation.CATEGORY_PAYMENT.equals(category)) {
            Log.e(TAG, "Not allowing defaults for category " + category);
            return null;
        }
        synchronized (mLock) {
            // Load current payment default from settings
            String name = Settings.Secure.getStringForUser(
                    mContext.getContentResolver(), Settings.Secure.NFC_PAYMENT_DEFAULT_COMPONENT,
                    userId);
            if (name != null) {
                ComponentName service = ComponentName.unflattenFromString(name);
                if (!validateInstalled || service == null) {
                    return service;
                } else {
                    return mServiceCache.hasService(userId, service) ? service : null;
                }
            } else {
                return null;
            }
        }
    }

    public List<ApduServiceInfo> getServicesForCategory(int userId, String category) {
        return mServiceCache.getServicesForCategory(userId, category);
    }

    public boolean setDefaultForNextTap(int userId, ComponentName service) {
        synchronized (mLock) {
            if (service != null) {
                mNextTapComponent = service;
            } else {
                mNextTapComponent = null;
            }
            // Update cache and routing table
            generateAidCacheLocked();
            updateRoutingLocked();
        }
        return true;
    }

    /**
     * Resolves an AID to a set of services that can handle it.
     */
     AidResolveInfo resolveAidLocked(List<ApduServiceInfo> resolvedServices, String aid) {
        if (resolvedServices == null || resolvedServices.size() == 0) {
            if (DBG) Log.d(TAG, "Could not resolve AID " + aid + " to any service.");
            return null;
        }
        AidResolveInfo resolveInfo = new AidResolveInfo();
        if (DBG) Log.d(TAG, "resolveAidLocked: resolving AID " + aid);
        resolveInfo.services = new ArrayList<ApduServiceInfo>();
        resolveInfo.services.addAll(resolvedServices);
        resolveInfo.defaultService = null;

        ComponentName defaultComponent = mNextTapComponent;
        if (DBG) Log.d(TAG, "resolveAidLocked: next tap component is " + defaultComponent);
        Set<String> paymentAids = mCategoryAids.get(CardEmulation.CATEGORY_PAYMENT);
        if (paymentAids != null && paymentAids.contains(aid)) {
            if (DBG) Log.d(TAG, "resolveAidLocked: AID " + aid + " is a payment AID");
            // This AID has been registered as a payment AID by at least one service.
            // Get default component for payment if no next tap default.
            if (defaultComponent == null) {
                defaultComponent = mCategoryDefaults.get(CardEmulation.CATEGORY_PAYMENT);
            }
            if (DBG) Log.d(TAG, "resolveAidLocked: default payment component is "
                    + defaultComponent);
            if (resolvedServices.size() == 1) {
                ApduServiceInfo resolvedService = resolvedServices.get(0);
                if (DBG) Log.d(TAG, "resolveAidLocked: resolved single service " +
                        resolvedService.getComponent());
                if (defaultComponent != null &&
                        defaultComponent.equals(resolvedService.getComponent())) {
                    if (DBG) Log.d(TAG, "resolveAidLocked: DECISION: routing to (default) " +
                        resolvedService.getComponent());
                    resolveInfo.defaultService = resolvedService;
                } else {
                    // So..since we resolved to only one service, and this AID
                    // is a payment AID, we know that this service is the only
                    // service that has registered for this AID and in fact claimed
                    // it was a payment AID.
                    // There's two cases:
                    // 1. All other AIDs in the payment group are uncontended:
                    //    in this case, just route to this app. It won't get
                    //    in the way of other apps, and is likely to interact
                    //    with different terminal infrastructure anyway.
                    // 2. At least one AID in the payment group is contended:
                    //    in this case, we should ask the user to confirm,
                    //    since it is likely to contend with other apps, even
                    //    when touching the same terminal.
                    boolean foundConflict = false;
                    for (AidGroup aidGroup : resolvedService.getAidGroups()) {
                        if (aidGroup.getCategory().equals(CardEmulation.CATEGORY_PAYMENT)) {
                            for (String registeredAid : aidGroup.getAids()) {
                                ArrayList<ApduServiceInfo> servicesForAid =
                                        mAidToServices.get(registeredAid);
                                if (servicesForAid != null && servicesForAid.size() > 1) {
                                    foundConflict = true;
                                }
                            }
                        }
                    }
                    if (!foundConflict) {
                        if (DBG) Log.d(TAG, "resolveAidLocked: DECISION: routing to " +
                            resolvedService.getComponent());
                        // Treat this as if it's the default for this AID
                        resolveInfo.defaultService = resolvedService;
                    } else {
                        // Allow this service to handle, but don't set as default
                        if (DBG) Log.d(TAG, "resolveAidLocked: DECISION: routing AID " + aid +
                                " to " + resolvedService.getComponent() +
                                ", but will ask confirmation because its AID group is contended.");
                    }
                }
            } else if (resolvedServices.size() > 1) {
                // More services have registered. If there's a default and it
                // registered this AID, go with the default. Otherwise, add all.
                if (DBG) Log.d(TAG, "resolveAidLocked: multiple services matched.");
                if (defaultComponent != null) {
                    for (ApduServiceInfo service : resolvedServices) {
                        if (service.getComponent().equals(defaultComponent)) {
                            if (DBG) Log.d(TAG, "resolveAidLocked: DECISION: routing to (default) "
                                    + service.getComponent());
                            resolveInfo.defaultService = service;
                            break;
                        }
                    }
                    if (resolveInfo.defaultService == null) {
                        if (DBG) Log.d(TAG, "resolveAidLocked: DECISION: routing to all services");
                    }
                }
            } // else -> should not hit, we checked for 0 before.
        } else {
            // This AID is not a payment AID, just return all components
            // that can handle it, but be mindful of (next tap) defaults.
            for (ApduServiceInfo service : resolvedServices) {
                if (service.getComponent().equals(defaultComponent)) {
                    if (DBG) Log.d(TAG, "resolveAidLocked: DECISION: cat OTHER AID, " +
                            "routing to (default) " + service.getComponent());
                    resolveInfo.defaultService = service;
                    break;
                }
            }
            if (resolveInfo.defaultService == null) {
                // If we didn't find the default, mark the first as default
                // if there is only one.
                if (resolveInfo.services.size() == 1) {
                    resolveInfo.defaultService = resolveInfo.services.get(0);
                    if (DBG) Log.d(TAG, "resolveAidLocked: DECISION: cat OTHER AID, " +
                            "routing to (default) " + resolveInfo.defaultService.getComponent());
                } else {
                    if (DBG) Log.d(TAG, "resolveAidLocked: DECISION: cat OTHER AID, routing all");
                }
            }
        }
        return resolveInfo;
    }

    void generateAidTreeLocked(List<ApduServiceInfo> services) {
        // Easiest is to just build the entire tree again
        mAidToServices.clear();
        for (ApduServiceInfo service : services) {
            if (DBG) Log.d(TAG, "generateAidTree component: " + service.getComponent());
            for (String aid : service.getAids()) {
                if (DBG) Log.d(TAG, "generateAidTree AID: " + aid);
                // Check if a mapping exists for this AID
                if (mAidToServices.containsKey(aid)) {
                    final ArrayList<ApduServiceInfo> aidServices = mAidToServices.get(aid);
                    aidServices.add(service);
                } else {
                    final ArrayList<ApduServiceInfo> aidServices =
                            new ArrayList<ApduServiceInfo>();
                    aidServices.add(service);
                    mAidToServices.put(aid, aidServices);
                }
            }
        }
    }

    void generateAidCategoriesLocked(List<ApduServiceInfo> services) {
        // Trash existing mapping
        mCategoryAids.clear();

        for (ApduServiceInfo service : services) {
            ArrayList<AidGroup> aidGroups = service.getAidGroups();
            if (aidGroups == null) continue;
            for (AidGroup aidGroup : aidGroups) {
                String groupCategory = aidGroup.getCategory();
                Set<String> categoryAids = mCategoryAids.get(groupCategory);
                if (categoryAids == null) {
                    categoryAids = new HashSet<String>();
                }
                categoryAids.addAll(aidGroup.getAids());
                mCategoryAids.put(groupCategory, categoryAids);
            }
        }
    }

    boolean updateFromSettingsLocked(int userId) {
        // Load current payment default from settings
        String name = Settings.Secure.getStringForUser(
                mContext.getContentResolver(), Settings.Secure.NFC_PAYMENT_DEFAULT_COMPONENT,
                userId);
        ComponentName newDefault = name != null ? ComponentName.unflattenFromString(name) : null;
        ComponentName oldDefault = mCategoryDefaults.put(CardEmulation.CATEGORY_PAYMENT,
                newDefault);
        if (DBG) Log.d(TAG, "Updating default component to: " + (name != null ?
                ComponentName.unflattenFromString(name) : "null"));
        return newDefault != oldDefault;
    }

    void generateAidCacheLocked() {
        mAidCache.clear();
        for (Map.Entry<String, ArrayList<ApduServiceInfo>> aidEntry:
                    mAidToServices.entrySet()) {
            String aid = aidEntry.getKey();
            if (!mAidCache.containsKey(aid)) {
                mAidCache.put(aid, resolveAidLocked(aidEntry.getValue(), aid));
            }
        }
    }

    void updateRoutingLocked() {
        if (!mNfcEnabled) {
            if (DBG) Log.d(TAG, "Not updating routing table because NFC is off.");
            return;
        }
        final Set<String> handledAids = new HashSet<String>();
        // For each AID, find interested services
        for (Map.Entry<String, AidResolveInfo> aidEntry:
                mAidCache.entrySet()) {
            String aid = aidEntry.getKey();
            AidResolveInfo resolveInfo = aidEntry.getValue();
            if (resolveInfo.services.size() == 0) {
                // No interested services, if there is a current routing remove it
                mRoutingManager.removeAid(aid);
            } else if (resolveInfo.defaultService != null) {
                // There is a default service set, route to that service
                mRoutingManager.setRouteForAid(aid, resolveInfo.defaultService.isOnHost());
            } else if (resolveInfo.services.size() == 1) {
                // Only one service, but not the default, must route to host
                // to ask the user to confirm.
                mRoutingManager.setRouteForAid(aid, true);
            } else if (resolveInfo.services.size() > 1) {
                // Multiple services, need to route to host to ask
                mRoutingManager.setRouteForAid(aid, true);
            }
            handledAids.add(aid);
        }
        // Now, find AIDs in the routing table that are no longer routed to
        // and remove them.
        Set<String> routedAids = mRoutingManager.getRoutedAids();
        for (String aid : routedAids) {
            if (!handledAids.contains(aid)) {
                if (DBG) Log.d(TAG, "Removing routing for AID " + aid + ", because " +
                        "there are no no interested services.");
                mRoutingManager.removeAid(aid);
            }
        }
        // And commit the routing
        mRoutingManager.commitRouting();
    }

    void showDefaultRemovedDialog() {
        Intent intent = new Intent(mContext, DefaultRemovedActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        mContext.startActivityAsUser(intent, UserHandle.CURRENT);
    }

    void onPaymentDefaultRemoved(int userId, List<ApduServiceInfo> services) {
        int numPaymentServices = 0;
        ComponentName lastFoundPaymentService = null;
        for (ApduServiceInfo service : services) {
            if (service.hasCategory(CardEmulation.CATEGORY_PAYMENT))  {
                numPaymentServices++;
                lastFoundPaymentService = service.getComponent();
            }
        }
        if (DBG) Log.d(TAG, "Number of payment services is " +
                Integer.toString(numPaymentServices));
        if (numPaymentServices == 0) {
            if (DBG) Log.d(TAG, "Default removed, no services left.");
            // No payment services left, unset default and don't ask the user
            setDefaultServiceForCategory(userId, null,
                    CardEmulation.CATEGORY_PAYMENT);
        } else if (numPaymentServices == 1) {
            // Only one left, automatically make it the default
            if (DBG) Log.d(TAG, "Default removed, making remaining service default.");
            setDefaultServiceForCategory(userId, lastFoundPaymentService,
                    CardEmulation.CATEGORY_PAYMENT);
        } else if (numPaymentServices > 1) {
            // More than one left, unset default and ask the user if he wants
            // to set a new one
            if (DBG) Log.d(TAG, "Default removed, asking user to pick.");
            setDefaultServiceForCategory(userId, null,
                    CardEmulation.CATEGORY_PAYMENT);
            showDefaultRemovedDialog();
        }
    }

    void setDefaultIfNeededLocked(int userId, List<ApduServiceInfo> services) {
        int numPaymentServices = 0;
        ComponentName lastFoundPaymentService = null;
        for (ApduServiceInfo service : services) {
            if (service.hasCategory(CardEmulation.CATEGORY_PAYMENT))  {
                numPaymentServices++;
                lastFoundPaymentService = service.getComponent();
            }
        }
        if (numPaymentServices > 1) {
            // More than one service left, leave default unset
            if (DBG) Log.d(TAG, "No default set, more than one service left.");
        } else if (numPaymentServices == 1) {
            // Make single found payment service the default
            if (DBG) Log.d(TAG, "No default set, making single service default.");
            setDefaultServiceForCategory(userId, lastFoundPaymentService,
                    CardEmulation.CATEGORY_PAYMENT);
        } else {
            // No payment services left, leave default at null
            if (DBG) Log.d(TAG, "No default set, last payment service removed.");
        }
    }

    void checkDefaultsLocked(int userId, List<ApduServiceInfo> services) {
        ComponentName defaultPaymentService =
                getDefaultServiceForCategory(userId, CardEmulation.CATEGORY_PAYMENT, false);
        if (DBG) Log.d(TAG, "Current default: " + defaultPaymentService);
        if (defaultPaymentService != null) {
            // Validate the default is still installed and handling payment
            ApduServiceInfo serviceInfo = mServiceCache.getService(userId, defaultPaymentService);
            if (serviceInfo == null) {
                Log.e(TAG, "Default payment service unexpectedly removed.");
                onPaymentDefaultRemoved(userId, services);
            } else if (!serviceInfo.hasCategory(CardEmulation.CATEGORY_PAYMENT)) {
                if (DBG) Log.d(TAG, "Default payment service had payment category removed");
                onPaymentDefaultRemoved(userId, services);
            } else {
                // Default still exists and handles the category, nothing do
                if (DBG) Log.d(TAG, "Default payment service still ok.");
            }
        } else {
            // A payment service may have been removed, leaving only one;
            // in that case, automatically set that app as default.
            setDefaultIfNeededLocked(userId, services);
        }
        updateFromSettingsLocked(userId);
    }

    @Override
    public void onServicesUpdated(int userId, List<ApduServiceInfo> services) {
        synchronized (mLock) {
            if (ActivityManager.getCurrentUser() == userId) {
                // Rebuild our internal data-structures
                checkDefaultsLocked(userId, services);
                generateAidTreeLocked(services);
                generateAidCategoriesLocked(services);
                generateAidCacheLocked();
                updateRoutingLocked();
            } else {
                if (DBG) Log.d(TAG, "Ignoring update because it's not for the current user.");
            }
        }
    }

    public void invalidateCache(int currentUser) {
        mServiceCache.invalidateCache(currentUser);
    }

    public void onNfcDisabled() {
        synchronized (mLock) {
            mNfcEnabled = false;
        }
        mServiceCache.onNfcDisabled();
        mRoutingManager.onNfccRoutingTableCleared();
    }

    public void onNfcEnabled() {
        synchronized (mLock) {
            mNfcEnabled = true;
            updateFromSettingsLocked(ActivityManager.getCurrentUser());
        }
        mServiceCache.onNfcEnabled();
    }

    String dumpEntry(Map.Entry<String, AidResolveInfo> entry) {
        StringBuilder sb = new StringBuilder();
        sb.append("    \"" + entry.getKey() + "\"\n");
        ApduServiceInfo defaultService = entry.getValue().defaultService;
        ComponentName defaultComponent = defaultService != null ?
                defaultService.getComponent() : null;

        for (ApduServiceInfo service : entry.getValue().services) {
            sb.append("        ");
            if (service.getComponent().equals(defaultComponent)) {
                sb.append("*DEFAULT* ");
            }
            sb.append(service.getComponent() +
                    " (Description: " + service.getDescription() + ")\n");
        }
        return sb.toString();
    }

    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
       mServiceCache.dump(fd, pw, args);
       pw.println("AID cache entries: ");
       for (Map.Entry<String, AidResolveInfo> entry : mAidCache.entrySet()) {
           pw.println(dumpEntry(entry));
       }
       pw.println("Category defaults: ");
       for (Map.Entry<String, ComponentName> entry : mCategoryDefaults.entrySet()) {
           pw.println("    " + entry.getKey() + "->" + entry.getValue());
       }
       pw.println("");
    }
}