nfc/cardemulation/RegisteredNfcFServicesCache.java

/*
 * Copyright (C) 2015 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.nfc.cardemulation;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlSerializer;

import android.app.ActivityManager;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.content.pm.PackageManager.NameNotFoundException;
import android.nfc.cardemulation.NfcFServiceInfo;
import android.nfc.cardemulation.NfcFCardEmulation;
import android.nfc.cardemulation.HostNfcFService;
import android.os.UserHandle;
import android.util.AtomicFile;
import android.util.Log;
import android.util.SparseArray;
import android.util.Xml;

import com.android.internal.util.FastXmlSerializer;
import com.google.android.collect.Maps;


import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;

public class RegisteredNfcFServicesCache {
    static final String XML_INDENT_OUTPUT_FEATURE = "http://xmlpull.org/v1/doc/features.html#indent-output";
    static final String TAG = "RegisteredNfcFServicesCache";
    static final boolean DBG = false;

    final Context mContext;
    final AtomicReference<BroadcastReceiver> mReceiver;

    final Object mLock = new Object();
    // All variables below synchronized on mLock

    // mUserServices holds the card emulation services that are running for each user
    final SparseArray<UserServices> mUserServices = new SparseArray<UserServices>();
    final Callback mCallback;
    final AtomicFile mDynamicSystemCodeNfcid2File;
    boolean mActivated = false;
    boolean mUserSwitched = false;

    public interface Callback {
        void onNfcFServicesUpdated(int userId, final List<NfcFServiceInfo> services);
    };

    static class DynamicSystemCode {
        public final int uid;
        public final String systemCode;

        DynamicSystemCode(int uid, String systemCode) {
            this.uid = uid;
            this.systemCode = systemCode;
        }
    };

    static class DynamicNfcid2 {
        public final int uid;
        public final String nfcid2;

        DynamicNfcid2(int uid, String nfcid2) {
            this.uid = uid;
            this.nfcid2 = nfcid2;
        }
    };

    private static class UserServices {
        /**
         * All services that have registered
         */
        final HashMap<ComponentName, NfcFServiceInfo> services =
                Maps.newHashMap(); // Re-built at run-time
        final HashMap<ComponentName, DynamicSystemCode> dynamicSystemCode =
                Maps.newHashMap(); // In memory cache of dynamic System Code store
        final HashMap<ComponentName, DynamicNfcid2> dynamicNfcid2 =
                Maps.newHashMap(); // In memory cache of dynamic NFCID2 store
    };

    private UserServices findOrCreateUserLocked(int userId) {
        UserServices userServices = mUserServices.get(userId);
        if (userServices == null) {
            userServices = new UserServices();
            mUserServices.put(userId, userServices);
        }
        return userServices;
    }

    public RegisteredNfcFServicesCache(Context context, Callback callback) {
        mContext = context;
        mCallback = callback;

        final BroadcastReceiver receiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                final int uid = intent.getIntExtra(Intent.EXTRA_UID, -1);
                String action = intent.getAction();
                if (DBG) Log.d(TAG, "Intent action: " + action);
                if (uid != -1) {
                    boolean replaced = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false) &&
                            (Intent.ACTION_PACKAGE_ADDED.equals(action) ||
                             Intent.ACTION_PACKAGE_REMOVED.equals(action));
                    if (!replaced) {
                        int currentUser = ActivityManager.getCurrentUser();
                        if (currentUser == UserHandle.getUserId(uid)) {
                            invalidateCache(UserHandle.getUserId(uid));
                        } else {
                            // Cache will automatically be updated on user switch
                        }
                    } else {
                        if (DBG) Log.d(TAG,
                                "Ignoring package intent due to package being replaced.");
                    }
                }
            }
        };
        mReceiver = new AtomicReference<BroadcastReceiver>(receiver);

        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
        intentFilter.addAction(Intent.ACTION_PACKAGE_CHANGED);
        intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
        intentFilter.addAction(Intent.ACTION_PACKAGE_REPLACED);
        intentFilter.addAction(Intent.ACTION_PACKAGE_FIRST_LAUNCH);
        intentFilter.addAction(Intent.ACTION_PACKAGE_RESTARTED);
        intentFilter.addDataScheme("package");
        mContext.registerReceiverAsUser(mReceiver.get(), UserHandle.ALL, intentFilter, null, null);

        // Register for events related to sdcard operations
        IntentFilter sdFilter = new IntentFilter();
        sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE);
        sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
        mContext.registerReceiverAsUser(mReceiver.get(), UserHandle.ALL, sdFilter, null, null);

        File dataDir = mContext.getFilesDir();
        mDynamicSystemCodeNfcid2File =
                new AtomicFile(new File(dataDir, "dynamic_systemcode_nfcid2.xml"));
    }

    void initialize() {
        synchronized (mLock) {
            readDynamicSystemCodeNfcid2Locked();
        }
        invalidateCache(ActivityManager.getCurrentUser());
    }

    void dump(ArrayList<NfcFServiceInfo> services) {
        for (NfcFServiceInfo service : services) {
            Log.d(TAG, service.toString());
        }
    }

    boolean containsServiceLocked(ArrayList<NfcFServiceInfo> services,
            ComponentName componentName) {
        for (NfcFServiceInfo service : services) {
            if (service.getComponent().equals(componentName)) return true;
        }
        return false;
    }

    public boolean hasService(int userId, ComponentName componentName) {
        return getService(userId, componentName) != null;
    }

    public NfcFServiceInfo getService(int userId, ComponentName componentName) {
        synchronized (mLock) {
            UserServices userServices = findOrCreateUserLocked(userId);
            return userServices.services.get(componentName);
        }
    }

    public List<NfcFServiceInfo> getServices(int userId) {
        final ArrayList<NfcFServiceInfo> services = new ArrayList<NfcFServiceInfo>();
        synchronized (mLock) {
            UserServices userServices = findOrCreateUserLocked(userId);
            services.addAll(userServices.services.values());
        }
        return services;
    }

    ArrayList<NfcFServiceInfo> getInstalledServices(int userId) {
        if (DBG) Log.d(TAG, "getInstalledServices");
        PackageManager pm;
        try {
            pm = mContext.createPackageContextAsUser("android", 0,
                    new UserHandle(userId)).getPackageManager();
        } catch (NameNotFoundException e) {
            Log.e(TAG, "Could not create user package context");
            return null;
        }

        ArrayList<NfcFServiceInfo> validServices = new ArrayList<NfcFServiceInfo>();

        List<ResolveInfo> resolvedServices = pm.queryIntentServicesAsUser(
                new Intent(HostNfcFService.SERVICE_INTERFACE),
                PackageManager.GET_META_DATA, userId);

        for (ResolveInfo resolvedService : resolvedServices) {
            try {
                ServiceInfo si = resolvedService.serviceInfo;
                ComponentName componentName = new ComponentName(si.packageName, si.name);
                // Check if the package holds the NFC permission
                if (pm.checkPermission(android.Manifest.permission.NFC, si.packageName) !=
                        PackageManager.PERMISSION_GRANTED) {
                    Log.e(TAG, "Skipping NfcF service " + componentName +
                            ": it does not require the permission " +
                            android.Manifest.permission.NFC);
                    continue;
                }
                if (!android.Manifest.permission.BIND_NFC_SERVICE.equals(
                        si.permission)) {
                    Log.e(TAG, "Skipping NfcF service " + componentName +
                            ": it does not require the permission " +
                            android.Manifest.permission.BIND_NFC_SERVICE);
                    continue;
                }
                NfcFServiceInfo service = new NfcFServiceInfo(pm, resolvedService);
                if (service != null) {
                    validServices.add(service);
                }
            } catch (XmlPullParserException e) {
                Log.w(TAG, "Unable to load component info " + resolvedService.toString(), e);
            } catch (IOException e) {
                Log.w(TAG, "Unable to load component info " + resolvedService.toString(), e);
            }
        }

        return validServices;
    }

    public void invalidateCache(int userId) {
        if (DBG) Log.d(TAG, "invalidateCache");
        final ArrayList<NfcFServiceInfo> validServices = getInstalledServices(userId);
        if (validServices == null) {
            return;
        }
        ArrayList<NfcFServiceInfo> newServices = null;
        synchronized (mLock) {
            UserServices userServices = findOrCreateUserLocked(userId);

            // Check update
            ArrayList<NfcFServiceInfo> cachedServices =
                    new ArrayList<NfcFServiceInfo>(userServices.services.values());
            ArrayList<NfcFServiceInfo> toBeAdded = new ArrayList<NfcFServiceInfo>();
            ArrayList<NfcFServiceInfo> toBeRemoved = new ArrayList<NfcFServiceInfo>();
            boolean matched = false;
            for (NfcFServiceInfo validService : validServices) {
                for (NfcFServiceInfo cachedService : cachedServices) {
                    if (validService.equals(cachedService)) {
                        matched = true;
                        break;
                    }
                }
                if (!matched) {
                    toBeAdded.add(validService);
                }
                matched = false;
            }
            for (NfcFServiceInfo cachedService : cachedServices) {
                for (NfcFServiceInfo validService : validServices) {
                    if (cachedService.equals(validService)) {
                        matched = true;
                        break;
                    }
                }
                if (!matched) {
                    toBeRemoved.add(cachedService);
                }
                matched = false;
            }
            if (mUserSwitched) {
                Log.d(TAG, "User switched, rebuild internal cache");
                mUserSwitched = false;
            } else if (toBeAdded.size() == 0 && toBeRemoved.size() == 0) {
                Log.d(TAG, "Service unchanged, not updating");
                return;
            }

            // Update cache
            for (NfcFServiceInfo service : toBeAdded) {
                userServices.services.put(service.getComponent(), service);
                if (DBG) Log.d(TAG, "Added service: " + service.getComponent());
            }
            for (NfcFServiceInfo service : toBeRemoved) {
                userServices.services.remove(service.getComponent());
                if (DBG) Log.d(TAG, "Removed service: " + service.getComponent());
            }
            // Apply dynamic System Code mappings
            ArrayList<ComponentName> toBeRemovedDynamicSystemCode =
                    new ArrayList<ComponentName>();
            for (Map.Entry<ComponentName, DynamicSystemCode> entry :
                    userServices.dynamicSystemCode.entrySet()) {
                // Verify component / uid match
                ComponentName componentName = entry.getKey();
                DynamicSystemCode dynamicSystemCode = entry.getValue();
                NfcFServiceInfo service = userServices.services.get(componentName);
                if (service == null || (service.getUid() != dynamicSystemCode.uid)) {
                    toBeRemovedDynamicSystemCode.add(componentName);
                    continue;
                } else {
                    service.setOrReplaceDynamicSystemCode(dynamicSystemCode.systemCode);
                }
            }
            // Apply dynamic NFCID2 mappings
            ArrayList<ComponentName> toBeRemovedDynamicNfcid2 =
                    new ArrayList<ComponentName>();
            for (Map.Entry<ComponentName, DynamicNfcid2> entry :
                    userServices.dynamicNfcid2.entrySet()) {
                // Verify component / uid match
                ComponentName componentName = entry.getKey();
                DynamicNfcid2 dynamicNfcid2 = entry.getValue();
                NfcFServiceInfo service = userServices.services.get(componentName);
                if (service == null || (service.getUid() != dynamicNfcid2.uid)) {
                    toBeRemovedDynamicNfcid2.add(componentName);
                    continue;
                } else {
                    service.setOrReplaceDynamicNfcid2(dynamicNfcid2.nfcid2);
                }
            }
            for (ComponentName removedComponent : toBeRemovedDynamicSystemCode) {
                Log.d(TAG, "Removing dynamic System Code registered by " +
                        removedComponent);
                userServices.dynamicSystemCode.remove(removedComponent);
            }
            for (ComponentName removedComponent : toBeRemovedDynamicNfcid2) {
                Log.d(TAG, "Removing dynamic NFCID2 registered by " +
                        removedComponent);
                userServices.dynamicNfcid2.remove(removedComponent);
            }
            // Assign a NFCID2 for services requesting a random NFCID2, then apply
            boolean nfcid2Assigned = false;
            for (Map.Entry<ComponentName, NfcFServiceInfo> entry :
                userServices.services.entrySet()) {
                NfcFServiceInfo service = entry.getValue();
                if (service.getNfcid2().equalsIgnoreCase("RANDOM")) {
                    String randomNfcid2 = generateRandomNfcid2();
                    service.setOrReplaceDynamicNfcid2(randomNfcid2);
                    DynamicNfcid2 dynamicNfcid2 =
                            new DynamicNfcid2(service.getUid(), randomNfcid2);
                    userServices.dynamicNfcid2.put(entry.getKey(), dynamicNfcid2);
                    nfcid2Assigned = true;
                }
            }

            // Persist to filesystem
            if (toBeRemovedDynamicSystemCode.size() > 0 ||
                    toBeRemovedDynamicNfcid2.size() > 0 ||
                    nfcid2Assigned) {
                writeDynamicSystemCodeNfcid2Locked();
            }

            newServices = new ArrayList<NfcFServiceInfo>(userServices.services.values());
        }
        mCallback.onNfcFServicesUpdated(userId, Collections.unmodifiableList(newServices));
        if (DBG) dump(newServices);
    }

    private void readDynamicSystemCodeNfcid2Locked() {
        if (DBG) Log.d(TAG, "readDynamicSystemCodeNfcid2Locked");
        FileInputStream fis = null;
        try {
            if (!mDynamicSystemCodeNfcid2File.getBaseFile().exists()) {
                Log.d(TAG, "Dynamic System Code, NFCID2 file does not exist.");
                return;
            }
            fis = mDynamicSystemCodeNfcid2File.openRead();
            XmlPullParser parser = Xml.newPullParser();
            parser.setInput(fis, null);
            int eventType = parser.getEventType();
            while (eventType != XmlPullParser.START_TAG &&
                    eventType != XmlPullParser.END_DOCUMENT) {
                eventType = parser.next();
            }
            String tagName = parser.getName();
            if ("services".equals(tagName)) {
                ComponentName componentName = null;
                int currentUid = -1;
                String systemCode = null;
                String nfcid2 = null;
                String description = null;
                while (eventType != XmlPullParser.END_DOCUMENT) {
                    tagName = parser.getName();
                    if (eventType == XmlPullParser.START_TAG) {
                        if ("service".equals(tagName) && parser.getDepth() == 2) {
                            String compString =
                                    parser.getAttributeValue(null, "component");
                            String uidString =
                                    parser.getAttributeValue(null, "uid");
                            String systemCodeString =
                                    parser.getAttributeValue(null, "system-code");
                            String descriptionString =
                                    parser.getAttributeValue(null, "description");
                            String nfcid2String =
                                    parser.getAttributeValue(null, "nfcid2");
                            if (compString == null || uidString == null) {
                                Log.e(TAG, "Invalid service attributes");
                            } else {
                                try {
                                    componentName = ComponentName.unflattenFromString(compString);
                                    currentUid = Integer.parseInt(uidString);
                                    systemCode = systemCodeString;
                                    description = descriptionString;
                                    nfcid2 = nfcid2String;
                                } catch (NumberFormatException e) {
                                    Log.e(TAG, "Could not parse service uid");
                                }
                            }
                        }
                    } else if (eventType == XmlPullParser.END_TAG) {
                        if ("service".equals(tagName)) {
                            // See if we have a valid service
                            if (componentName != null && currentUid >= 0) {
                                final int userId = UserHandle.getUserId(currentUid);
                                UserServices userServices = findOrCreateUserLocked(userId);
                                if (systemCode != null) {
                                    DynamicSystemCode dynamicSystemCode =
                                            new DynamicSystemCode(currentUid, systemCode);
                                    userServices.dynamicSystemCode.put(
                                            componentName, dynamicSystemCode);
                                }
                                if (nfcid2 != null) {
                                    DynamicNfcid2 dynamicNfcid2 =
                                            new DynamicNfcid2(currentUid, nfcid2);
                                    userServices.dynamicNfcid2.put(
                                            componentName, dynamicNfcid2);
                                }
                            }
                            componentName = null;
                            currentUid = -1;
                            systemCode = null;
                            description = null;
                            nfcid2 = null;
                        }
                    }
                    eventType = parser.next();
                };
            }
        } catch (Exception e) {
            Log.e(TAG, "Could not parse dynamic System Code, NFCID2 file, trashing.");
            mDynamicSystemCodeNfcid2File.delete();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                }
            }
        }
    }

    private boolean writeDynamicSystemCodeNfcid2Locked() {
        if (DBG) Log.d(TAG, "writeDynamicSystemCodeNfcid2Locked");
        FileOutputStream fos = null;
        try {
            fos = mDynamicSystemCodeNfcid2File.startWrite();
            XmlSerializer out = new FastXmlSerializer();
            out.setOutput(fos, "utf-8");
            out.startDocument(null, true);
            out.setFeature(XML_INDENT_OUTPUT_FEATURE, true);
            out.startTag(null, "services");
            for (int i = 0; i < mUserServices.size(); i++) {
                final UserServices userServices = mUserServices.valueAt(i);
                for (Map.Entry<ComponentName, DynamicSystemCode> entry :
                        userServices.dynamicSystemCode.entrySet()) {
                    out.startTag(null, "service");
                    out.attribute(null, "component", entry.getKey().flattenToString());
                    out.attribute(null, "uid", Integer.toString(entry.getValue().uid));
                    out.attribute(null, "system-code", entry.getValue().systemCode);
                    if (userServices.dynamicNfcid2.containsKey(entry.getKey())) {
                        out.attribute(null, "nfcid2",
                                userServices.dynamicNfcid2.get(entry.getKey()).nfcid2);
                    }
                    out.endTag(null, "service");
                }
                for (Map.Entry<ComponentName, DynamicNfcid2> entry :
                        userServices.dynamicNfcid2.entrySet()) {
                    if (!userServices.dynamicSystemCode.containsKey(entry.getKey())) {
                        out.startTag(null, "service");
                        out.attribute(null, "component", entry.getKey().flattenToString());
                        out.attribute(null, "uid", Integer.toString(entry.getValue().uid));
                        out.attribute(null, "nfcid2", entry.getValue().nfcid2);
                        out.endTag(null, "service");
                    }
                }
            }
            out.endTag(null, "services");
            out.endDocument();
            mDynamicSystemCodeNfcid2File.finishWrite(fos);
            return true;
        } catch (Exception e) {
            Log.e(TAG, "Error writing dynamic System Code, NFCID2", e);
            if (fos != null) {
                mDynamicSystemCodeNfcid2File.failWrite(fos);
            }
            return false;
        }
    }

    public boolean registerSystemCodeForService(int userId, int uid,
            ComponentName componentName, String systemCode) {
        if (DBG) Log.d(TAG, "registerSystemCodeForService");
        ArrayList<NfcFServiceInfo> newServices = null;
        boolean success;
        synchronized (mLock) {
            if (mActivated) {
                Log.d(TAG, "failed to register System Code during activation");
                return false;
            }
            UserServices userServices = findOrCreateUserLocked(userId);
            // Check if we can find this service
            NfcFServiceInfo service = getService(userId, componentName);
            if (service == null) {
                Log.e(TAG, "Service " + componentName + " does not exist.");
                return false;
            }
            if (service.getUid() != uid) {
                // This is probably a good indication something is wrong here.
                // Either newer service installed with different uid (but then
                // we should have known about it), or somebody calling us from
                // a different uid.
                Log.e(TAG, "UID mismatch.");
                return false;
            }
            if (!systemCode.equalsIgnoreCase("NULL") &&
                    !NfcFCardEmulation.isValidSystemCode(systemCode)) {
                Log.e(TAG, "System Code " + systemCode + " is not a valid System Code");
                return false;
            }
            // Apply dynamic System Code mappings
            systemCode = systemCode.toUpperCase();
            DynamicSystemCode oldDynamicSystemCode =
                    userServices.dynamicSystemCode.get(componentName);
            DynamicSystemCode dynamicSystemCode = new DynamicSystemCode(uid, systemCode);
            userServices.dynamicSystemCode.put(componentName, dynamicSystemCode);
            success = writeDynamicSystemCodeNfcid2Locked();
            if (success) {
                service.setOrReplaceDynamicSystemCode(systemCode);
                newServices = new ArrayList<NfcFServiceInfo>(userServices.services.values());
            } else {
                Log.e(TAG, "Failed to persist System Code.");
                // Undo registration
                if (oldDynamicSystemCode == null) {
                    userServices.dynamicSystemCode.remove(componentName);
                } else {
                    userServices.dynamicSystemCode.put(componentName, oldDynamicSystemCode);
                }
            }
        }
        if (success) {
            // Make callback without the lock held
            mCallback.onNfcFServicesUpdated(userId, newServices);
        }
        return success;
    }

    public String getSystemCodeForService(int userId, int uid, ComponentName componentName) {
        if (DBG) Log.d(TAG, "getSystemCodeForService");
        NfcFServiceInfo service = getService(userId, componentName);
        if (service != null) {
            if (service.getUid() != uid) {
                Log.e(TAG, "UID mismatch");
                return null;
            }
            return service.getSystemCode();
        } else {
            Log.e(TAG, "Could not find service " + componentName);
            return null;
        }
    }

    public boolean removeSystemCodeForService(int userId, int uid, ComponentName componentName) {
        if (DBG) Log.d(TAG, "removeSystemCodeForService");
        return registerSystemCodeForService(userId, uid, componentName, "NULL");
    }

    public boolean setNfcid2ForService(int userId, int uid,
            ComponentName componentName, String nfcid2) {
        if (DBG) Log.d(TAG, "setNfcid2ForService");
        ArrayList<NfcFServiceInfo> newServices = null;
        boolean success;
        synchronized (mLock) {
            if (mActivated) {
                Log.d(TAG, "failed to set NFCID2 during activation");
                return false;
            }
            UserServices userServices = findOrCreateUserLocked(userId);
            // Check if we can find this service
            NfcFServiceInfo service = getService(userId, componentName);
            if (service == null) {
                Log.e(TAG, "Service " + componentName + " does not exist.");
                return false;
            }
            if (service.getUid() != uid) {
                // This is probably a good indication something is wrong here.
                // Either newer service installed with different uid (but then
                // we should have known about it), or somebody calling us from
                // a different uid.
                Log.e(TAG, "UID mismatch.");
                return false;
            }
            if (!NfcFCardEmulation.isValidNfcid2(nfcid2)) {
                Log.e(TAG, "NFCID2 " + nfcid2 + " is not a valid NFCID2");
                return false;
            }
            // Apply dynamic NFCID2 mappings
            nfcid2 = nfcid2.toUpperCase();
            DynamicNfcid2 oldDynamicNfcid2 = userServices.dynamicNfcid2.get(componentName);
            DynamicNfcid2 dynamicNfcid2 = new DynamicNfcid2(uid, nfcid2);
            userServices.dynamicNfcid2.put(componentName, dynamicNfcid2);
            success = writeDynamicSystemCodeNfcid2Locked();
            if (success) {
                service.setOrReplaceDynamicNfcid2(nfcid2);
                newServices = new ArrayList<NfcFServiceInfo>(userServices.services.values());
            } else {
                Log.e(TAG, "Failed to persist NFCID2.");
                // Undo registration
                if (oldDynamicNfcid2 == null) {
                    userServices.dynamicNfcid2.remove(componentName);
                } else {
                    userServices.dynamicNfcid2.put(componentName, oldDynamicNfcid2);
                }
            }
        }
        if (success) {
            // Make callback without the lock held
            mCallback.onNfcFServicesUpdated(userId, newServices);
        }
        return success;
    }

    public String getNfcid2ForService(int userId, int uid, ComponentName componentName) {
        if (DBG) Log.d(TAG, "getNfcid2ForService");
        NfcFServiceInfo service = getService(userId, componentName);
        if (service != null) {
            if (service.getUid() != uid) {
                Log.e(TAG, "UID mismatch");
                return null;
            }
            return service.getNfcid2();
        } else {
            Log.e(TAG, "Could not find service " + componentName);
            return null;
        }
    }

    public void onHostEmulationActivated() {
        if (DBG) Log.d(TAG, "onHostEmulationActivated");
        synchronized (mLock) {
            mActivated = true;
        }
    }

    public void onHostEmulationDeactivated() {
        if (DBG) Log.d(TAG, "onHostEmulationDeactivated");
        synchronized (mLock) {
            mActivated = false;
        }
    }

    public void onNfcDisabled() {
        synchronized (mLock) {
            mActivated = false;
        }
    }

    public void onUserSwitched() {
        synchronized (mLock) {
            mUserSwitched = true;
        }
    }

    private String generateRandomNfcid2() {
        long min = 0L;
        long max = 0xFFFFFFFFFFFFL;

        long randomNfcid2 = (long)Math.floor(Math.random() * (max-min+1)) + min;
        return String.format("02FE%02X%02X%02X%02X%02X%02X",
                (randomNfcid2 >>> 8 * 5) & 0xFF, (randomNfcid2 >>> 8 * 4) & 0xFF,
                (randomNfcid2 >>> 8 * 3) & 0xFF, (randomNfcid2 >>> 8 * 2) & 0xFF,
                (randomNfcid2 >>> 8 * 1) & 0xFF, (randomNfcid2 >>> 8 * 0) & 0xFF);
    }

    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
        pw.println("Registered HCE-F services for current user: ");
        synchronized (mLock) {
            UserServices userServices = findOrCreateUserLocked(ActivityManager.getCurrentUser());
            for (NfcFServiceInfo service : userServices.services.values()) {
                service.dump(fd, pw, args);
                pw.println("");
            }
            pw.println("");
        }
    }

}