src/com/android/nfc/cardemulation/RegisteredServicesCache.java

/*
 * Copyright (C) 2013 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.
 */
/******************************************************************************
*
*  The original Work has been changed by NXP.
*
*  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.
*
*  Copyright 2018-2019 NXP
*
******************************************************************************/
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.net.Uri;
import android.nfc.cardemulation.NfcAidGroup;
import android.nfc.cardemulation.NfcApduServiceInfo;
import android.nfc.cardemulation.AidGroup;
import android.nfc.cardemulation.CardEmulation;
import android.nfc.cardemulation.HostApduService;
import android.nfc.cardemulation.OffHostApduService;
import android.os.UserHandle;
import android.util.AtomicFile;
import android.util.Log;
import android.util.SparseArray;
import android.util.Xml;
import com.nxp.nfc.NfcConstants;

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;
import com.android.nfc.NfcService;
import android.os.SystemProperties;

/**
 * This class is inspired by android.content.pm.RegisteredServicesCache
 * That class was not re-used because it doesn't support dynamically
 * registering additional properties, but generates everything from
 * the manifest. Since we have some properties that are not in the manifest,
 * it's less suited.
 */
public class RegisteredServicesCache {
    static final String XML_INDENT_OUTPUT_FEATURE = "http://xmlpull.org/v1/doc/features.html#indent-output";
    static final String TAG = "RegisteredServicesCache";
    static final boolean DEBUG =
        ((SystemProperties.get("persist.nfc.ce_debug").equals("1")) ? true : false);
    static final String SERVICE_STATE_FILE_VERSION="1.0";

    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 mDynamicSettingsFile;
    final AtomicFile mServiceStateFile;
    final HashMap<ComponentName, NfcApduServiceInfo> mAllServices = Maps.newHashMap();
    HashMap<String, HashMap<ComponentName, Integer>> installedServices = new HashMap<>();

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

    static class DynamicSettings {
        public final int uid;
        public final HashMap<String, NfcAidGroup> aidGroups = Maps.newHashMap();
        public String offHostSE;

        DynamicSettings(int uid) {
            this.uid = uid;
        }
    };

    private static class UserServices {
        /**
         * All services that have registered
         */
        final HashMap<ComponentName, NfcApduServiceInfo> services =
                Maps.newHashMap(); // Re-built at run-time
        final HashMap<ComponentName, DynamicSettings> dynamicSettings =
                Maps.newHashMap(); // In memory cache of dynamic Setting store
    };

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

    public RegisteredServicesCache(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 (DEBUG) Log.d(TAG, "Intent action: " + action);
                if (uid != -1) {
                    int currentUser = ActivityManager.getCurrentUser();
                    if (currentUser == UserHandle.getUserId(uid)) {
                        if(Intent.ACTION_PACKAGE_REMOVED.equals(action)) {
                            Uri uri = intent.getData();
                            String pkg = uri != null ? uri.getSchemeSpecificPart() : null;
                        }
                        boolean replaced = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false) &&
                                (Intent.ACTION_PACKAGE_ADDED.equals(action) ||
                                 Intent.ACTION_PACKAGE_REMOVED.equals(action));
                        if (!replaced) {
                        invalidateCache(UserHandle.getUserId(uid));
                        } else {
                            // Cache will automatically be updated on user switch
                            if (DEBUG) Log.d(TAG, " Not removing service here " + replaced);
                        }
                    } else {
                        if (DEBUG) 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();
        mDynamicSettingsFile = new AtomicFile(new File(dataDir, "dynamic_aids.xml"));
        mServiceStateFile = new AtomicFile(new File(dataDir, "service_state.xml"));
    }

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

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

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

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

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

    public List<NfcApduServiceInfo> getServicesForCategory(int userId, String category) {
        final ArrayList<NfcApduServiceInfo> services = new ArrayList<NfcApduServiceInfo>();
        synchronized (mLock) {
            UserServices userServices = findOrCreateUserLocked(userId);
            for (NfcApduServiceInfo service : userServices.services.values()) {
                if (service.hasCategory(category) &&
                        (service.getAidCacheSizeForCategory(category) > 0)) services.add(service);
            }
        }
        return services;
    }

    ArrayList<NfcApduServiceInfo> getInstalledServices(int userId) {
        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;
        }
        mAllServices.clear();
        ArrayList<NfcApduServiceInfo> validServices = new ArrayList<NfcApduServiceInfo>();

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

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

        for (ResolveInfo resolvedService : resolvedServices) {
            try {
                boolean onHost = !resolvedOffHostServices.contains(resolvedService);
                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 application component " + componentName +
                            ": it must request the permission " +
                            android.Manifest.permission.NFC);
                    continue;
                }
                if (!android.Manifest.permission.BIND_NFC_SERVICE.equals(
                        si.permission)) {
                    Log.e(TAG, "Skipping APDU service " + componentName +
                            ": it does not require the permission " +
                            android.Manifest.permission.BIND_NFC_SERVICE);
                    continue;
                }
                NfcApduServiceInfo service = new NfcApduServiceInfo(pm, resolvedService, onHost);
                if (service != null) {
                    validServices.add(service);
                    if(!onHost)
                        mAllServices.put(componentName, 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 ArrayList<NfcApduServiceInfo> getAllServices() {
        return new ArrayList<NfcApduServiceInfo>(mAllServices.values());//mAllServices;
    }

    public HashMap<ComponentName, NfcApduServiceInfo> getAllStaticHashServices() {
        return mAllServices;
    }

    public void invalidateCache(int userId) {
        final ArrayList<NfcApduServiceInfo> validServices = getInstalledServices(userId);
        if (validServices == null) {
            return;
        }
        synchronized (mLock) {
            UserServices userServices = findOrCreateUserLocked(userId);

            // Find removed services
            Iterator<Map.Entry<ComponentName, NfcApduServiceInfo>> it =
                    userServices.services.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry<ComponentName, NfcApduServiceInfo> entry =
                        (Map.Entry<ComponentName, NfcApduServiceInfo>) it.next();
                if (!containsServiceLocked(validServices, entry.getKey())) {
                    Log.d(TAG, "Service removed: " + entry.getKey());
                    it.remove();
                }
            }
            for (NfcApduServiceInfo service : validServices) {
                if (DEBUG) Log.d(TAG, "Adding service: " + service.getComponent() +
                        " AIDs: " + service.getAids());
                userServices.services.put(service.getComponent(), service);
            }

            // Apply dynamic Setting mappings
            ArrayList<ComponentName> toBeRemoved = new ArrayList<ComponentName>();
            for (Map.Entry<ComponentName, DynamicSettings> entry :
                    userServices.dynamicSettings.entrySet()) {
                // Verify component / uid match
                ComponentName component = entry.getKey();
                DynamicSettings dynamicSettings = entry.getValue();
                NfcApduServiceInfo serviceInfo = userServices.services.get(component);
                if (serviceInfo == null || (serviceInfo.getUid() != dynamicSettings.uid)) {
                    toBeRemoved.add(component);
                    continue;
                } else {
                    for (NfcAidGroup group : dynamicSettings.aidGroups.values()) {
                        serviceInfo.setOrReplaceDynamicNfcAidGroup(group);
                    }
                    if (dynamicSettings.offHostSE != null) {
                      serviceInfo.setOffHostSecureElement(dynamicSettings.offHostSE);
                    }
                }
            }

            if (toBeRemoved.size() > 0) {
                for (ComponentName component : toBeRemoved) {
                    Log.d(TAG, "Removing dynamic Settings registered by " + component);
                    userServices.dynamicSettings.remove(component);
                }
                // Persist to filesystem
                writeDynamicSettingsLocked();
            }
            updateServiceStateFromFile(userId);
            Log.e(TAG,"1"+Thread.currentThread().getStackTrace()[2].getMethodName()+":WriteServiceStateToFile");
            writeServiceStateToFile(userId);
        }

        mCallback.onServicesUpdated(userId, Collections.unmodifiableList(validServices));
        dump(validServices);
    }

    private void readDynamicSettingsLocked() {
        FileInputStream fis = null;
        try {
            if (!mDynamicSettingsFile.getBaseFile().exists()) {
                Log.d(TAG, "Dynamic AIDs file does not exist.");
                return;
            }
            fis = mDynamicSettingsFile.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)) {
                boolean inService = false;
                ComponentName currentComponent = null;
                int currentUid = -1;
                String currentOffHostSE = null;
                ArrayList<NfcAidGroup> currentGroups = new ArrayList<NfcAidGroup>();
                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 offHostString = parser.getAttributeValue(null, "offHostSE");
                            if (compString == null || uidString == null) {
                                Log.e(TAG, "Invalid service attributes");
                            } else {
                                try {
                                    currentUid = Integer.parseInt(uidString);
                                    currentComponent = ComponentName.unflattenFromString(compString);
                                    currentOffHostSE = offHostString;
                                    inService = true;
                                } catch (NumberFormatException e) {
                                    Log.e(TAG, "Could not parse service uid");
                                }
                            }
                        }
                        if ("aid-group".equals(tagName) && parser.getDepth() == 3 && inService) {
                            NfcAidGroup group = NfcAidGroup.createFromXml(parser);
                            if (group != null) {
                                currentGroups.add(group);
                            } else {
                                Log.e(TAG, "Could not parse AID group.");
                            }
                        }
                    } else if (eventType == XmlPullParser.END_TAG) {
                        if ("service".equals(tagName)) {
                            // See if we have a valid service
                            if (currentComponent != null && currentUid >= 0 &&
                                    (currentGroups.size() > 0 || currentOffHostSE != null)) {
                                final int userId = UserHandle.getUserId(currentUid);
                                DynamicSettings dynSettings = new DynamicSettings(currentUid);
                                for (NfcAidGroup group : currentGroups) {
                                    dynSettings.aidGroups.put(group.getCategory(), group);
                                }
                                dynSettings.offHostSE = currentOffHostSE;
                                UserServices services = findOrCreateUserLocked(userId);
                                services.dynamicSettings.put(currentComponent, dynSettings);
                            }
                            currentUid = -1;
                            currentComponent = null;
                            currentGroups.clear();
                            inService = false;
                            currentOffHostSE = null;
                        }
                    }
                    eventType = parser.next();
                };
            }
        } catch (Exception e) {
            Log.e(TAG, "Could not parse dynamic Settings file, trashing.");
            mDynamicSettingsFile.delete();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                }
            }
        }
    }

    private boolean writeDynamicSettingsLocked() {
        FileOutputStream fos = null;
        try {
            fos = mDynamicSettingsFile.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 user = mUserServices.valueAt(i);
                for (Map.Entry<ComponentName, DynamicSettings> service : user.dynamicSettings.entrySet()) {
                    out.startTag(null, "service");
                    out.attribute(null, "component", service.getKey().flattenToString());
                    out.attribute(null, "uid", Integer.toString(service.getValue().uid));
                    if(service.getValue().offHostSE != null) {
                        out.attribute(null, "offHostSE", service.getValue().offHostSE);
                    }
                    for (NfcAidGroup group : service.getValue().aidGroups.values()) {
                        group.writeAsXml(out);
                    }
                    out.endTag(null, "service");
                }
            }
            out.endTag(null, "services");
            out.endDocument();
            mDynamicSettingsFile.finishWrite(fos);
            return true;
        } catch (Exception e) {
            Log.e(TAG, "Error writing dynamic Settings", e);
            if (fos != null) {
                mDynamicSettingsFile.failWrite(fos);
            }
            return false;
        }
    }

    private void updateServiceStateFromFile(int currUserId)
    {
        FileInputStream fis = null;
        try {
             /*if(NfcService.getInstance().getAidRoutingTableStatus() == 0x00) {
                 Log.e(TAG, " Aid Routing Table still  availble , No need to disable services");
                 return;
             }*/
             Log.d(TAG, " Reading service state data always from file");
             if(!mServiceStateFile.getBaseFile().exists()) {
                 Log.d(TAG,"mServiceStateFile does not exist");
                 return;
             }
             fis = mServiceStateFile.openRead();
             XmlPullParser parser = Xml.newPullParser();
             parser.setInput(fis , null);
             int eventType = parser.getEventType();
             int currUid = -1;
             ComponentName currComponent = null;
             //HashMap<ComponentName ,NfcApduServiceInfo> nfcOffHostServiceMap = mRegisteredNfcServicesCache.getApduservicesMaps();
             int state = NfcConstants.SERVICE_STATE_ENABLED;

             while (eventType != XmlPullParser.START_TAG &&
                     eventType != XmlPullParser.END_DOCUMENT) {
                 eventType = parser.next();
             }
             String tagName = parser.getName();
             String fileVersion = "null";
             /**
              * Get the version of the Service state file.
              * if the version is 1.0, service states are stored as integers(0,1,2,3)
              * or else service states are stored as boolean (true or false)
              */
             if("Version".equals(tagName)){
                 fileVersion = parser.getAttributeValue(null ,"FileVersion");
                 Log.d(TAG, "ServiceStateFileVersion="+fileVersion);
                 eventType = parser.next();
                 while (eventType != XmlPullParser.START_TAG &&
                         eventType != XmlPullParser.END_DOCUMENT) {
                     eventType = parser.next();
                 }
                 tagName = parser.getName();
                 Log.e(TAG, "Next Tag="+tagName);
             }
             if ("services".equals(tagName)) {
                 while (eventType != XmlPullParser.END_DOCUMENT) {
                     tagName = parser.getName();
                     if (eventType == XmlPullParser.START_TAG) {
                         if("service".equals(tagName) && parser.getDepth() == 0x02) {
                             String compString  = parser.getAttributeValue(null ,"component");
                             String uidString   = parser.getAttributeValue(null ,"uid");
                             String stateString = parser.getAttributeValue(null ,"serviceState");

                             if(compString == null || uidString == null || stateString == null) {
                                 Log.e(TAG, "Invalid service attributes");
                             } else {
                                try {
                                    currUid       = Integer.parseInt(uidString);
                                    currComponent = ComponentName.unflattenFromString(compString);
                                    Log.d(TAG, " curr component "+compString);
                                    Log.d(TAG, " curr uid "+uidString);
                                    Log.d(TAG, " curr state "+stateString);

                                    if(fileVersion.equals("null")){
                                    if(stateString.equalsIgnoreCase("false"))
                                        state = NfcConstants.SERVICE_STATE_DISABLED;
                                    else
                                        state = NfcConstants.SERVICE_STATE_ENABLED;
                                    }else if(fileVersion.equals("1.0")){
                                        state = Integer.parseInt(stateString);
                                        if(state<NfcConstants.SERVICE_STATE_DISABLED || state > NfcConstants.SERVICE_STATE_DISABLING)
                                            Log.e(TAG, "Invalid Service state");
                                    }
                                    /*Load all the servies info into local memory from xml file and
                                     *later update the xml file with updated information
                                     *This way it can retain previous user's information even after switching to different user
                                     * */
                                    if(installedServices.containsKey(uidString))
                                    {
                                        Log.e(TAG, "installedServices contains uidString : " +uidString);
                                        HashMap<ComponentName, Integer> componentStates;
                                        componentStates = installedServices.get(uidString);
                                                componentStates.put(currComponent,state);
                                    }else
                                    {
                                        Log.e(TAG, "installedServices no uidString ");
                                        HashMap<ComponentName, Integer> componentStates = new HashMap<>();
                                        componentStates.put(currComponent,state);
                                        installedServices.put(uidString,componentStates);
                                    }

                                } catch (NumberFormatException e) {
                                    Log.e(TAG, "could not parse the service attributes");
                                }
                             }
                         }
                     } else  if (eventType == XmlPullParser.END_TAG) {
                         if("service".equals(tagName)) {
                             final int userId = UserHandle.getUserId(currUid);

                                 UserServices serviceCache = findOrCreateUserLocked(userId);
                                 NfcApduServiceInfo serviceInfo = serviceCache.services.get(currComponent);

                                 if(serviceInfo != null) {
                                    serviceInfo.setServiceState(CardEmulation.CATEGORY_OTHER ,state);
                                 }
                         }
                         currUid       = -1;
                         currComponent = null;
                         state         = NfcConstants.SERVICE_STATE_ENABLED;
                     }

                     eventType = parser.next();
                 }
             }
        } catch(Exception e) {
            mServiceStateFile.delete();
            Log.e(TAG, "could not parse the seriveState file , thrashing the file " + e);
        } finally {
            try {
                if(fis != null) {
                    fis.close();
                }
            } catch ( Exception e) {
            }
        }
    }

    private boolean writeServiceStateToFile(int currUserId) {
        FileOutputStream fos = null;
        //ArrayList<NfcApduServiceInfo> nfcOffHostServiceCache = mRegisteredNfcServicesCache.getApduservicesList();
        /*if(NfcService.getInstance().getAidRoutingTableStatus() == 0x00) {
            Log.e(TAG, " Aid Routing Table still  availble , No need to disable services");
            return false;
        }*/
        Log.e(TAG, " Writing service state Data Always");
        if(currUserId != ActivityManager.getCurrentUser()) {
            return false;
        }
        int state = NfcConstants.SERVICE_STATE_ENABLED;
        try {
            fos = mServiceStateFile.startWrite();
            XmlSerializer out = new FastXmlSerializer();
            out.setOutput(fos, "utf-8");
            out.startDocument(null , true);
            out.setFeature(XML_INDENT_OUTPUT_FEATURE, true);
            out.startTag(null ,"Version");
            out.attribute(null, "FileVersion", SERVICE_STATE_FILE_VERSION);
            out.endTag(null ,"Version");
            out.startTag(null ,"services");
            for(int userId = 0; userId < mUserServices.size(); userId++) {
                final UserServices userServices = mUserServices.valueAt(userId);
                for (NfcApduServiceInfo serviceInfo : userServices.services.values()) {
                    if(!serviceInfo.hasCategory(CardEmulation.CATEGORY_OTHER)) {
                        continue;
                    }
                    out.startTag(null ,"service");
                    out.attribute(null, "component", serviceInfo.getComponent().flattenToString());
                    Log.e(TAG,"component name"+ serviceInfo.getComponent().flattenToString());
                    out.attribute(null, "uid", Integer.toString(serviceInfo.getUid()));

                    boolean isServiceInstalled = false;
                    if(installedServices.containsKey(Integer.toString(serviceInfo.getUid()))){
                        HashMap<ComponentName, Integer> componentStates = installedServices.get(Integer.toString(serviceInfo.getUid()));
                        if (componentStates.containsKey(serviceInfo.getComponent())) {
                            state = componentStates.get(serviceInfo.getComponent());
                            componentStates.remove(serviceInfo.getComponent());
                            if(componentStates.isEmpty())
                            {
                                installedServices.remove(Integer.toString(serviceInfo.getUid()));
                            }
                            isServiceInstalled = true;
                        }
                    }
                    if (!isServiceInstalled) {
                        state = serviceInfo.getServiceState(CardEmulation.CATEGORY_OTHER);
                    }
                    out.attribute(null, "serviceState", Integer.toString(state));
                    out.endTag(null, "service");
                }
            }
            out.endTag(null ,"services");
            out.endDocument();
            mServiceStateFile.finishWrite(fos);
            return true;
        } catch ( Exception e){
            Log.e(TAG,"Failed to write serviceStateFile xml");
            e.printStackTrace();
            if (fos != null) {
                mServiceStateFile.failWrite(fos);
            }
            return false;
        }
    }

    public int updateServiceState(int userId , int uid,
            Map<String , Boolean> serviceState) {
        boolean success = false;
        //HashMap<ComponentName ,NfcApduServiceInfo> nfcOffHostServiceMap = mRegisteredNfcServicesCache.getApduservicesMaps();
        if(NfcService.getInstance().getAidRoutingTableStatus() == 0x00) {
            Log.e(TAG, " Aid Routing Table still  availble , No need to disable services");
            return 0xFF;
        }
        synchronized(mLock) {
            Iterator<Map.Entry<String , Boolean>> it =
                    serviceState.entrySet().iterator();
            while(it.hasNext()) {
                Map.Entry<String , Boolean> entry =
                        (Map.Entry<String , Boolean>) it.next();
                ComponentName componentName = ComponentName.unflattenFromString(entry.getKey());
                NfcApduServiceInfo serviceInfo = getService(userId, componentName);
                Log.e(TAG, "updateServiceState " + entry.getKey());
                Log.e(TAG, "updateServiceState  " + entry.getValue());
                if (serviceInfo != null) {
                    serviceInfo.enableService(CardEmulation.CATEGORY_OTHER, entry.getValue());
                } else {
                      Log.e(TAG, "Could not find service " + componentName);
                      return 0xFF;
                }
            }
            Log.e(TAG,"2"+Thread.currentThread().getStackTrace()[2].getMethodName()+":WriteServiceStateToFile");
            success = writeServiceStateToFile(userId);
        }
        invalidateCache(ActivityManager.getCurrentUser());
        return (success?0x00:0xFF);
    }

    public boolean setOffHostSecureElement(int userId, int uid, ComponentName componentName,
            String offHostSE) {
        ArrayList<NfcApduServiceInfo> newServices = null;
        synchronized (mLock) {
            UserServices services = findOrCreateUserLocked(userId);
            // Check if we can find this service
            NfcApduServiceInfo serviceInfo = getService(userId, componentName);
            if (serviceInfo == null) {
                Log.e(TAG, "Service " + componentName + " does not exist.");
                return false;
            }
            if (serviceInfo.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 (offHostSE == null || serviceInfo.isOnHost()) {
                Log.e(TAG, "OffHostSE mismatch with Service type");
                return false;
            }

            DynamicSettings dynSettings = services.dynamicSettings.get(componentName);
            if (dynSettings == null) {
                dynSettings = new DynamicSettings(uid);
            }
            dynSettings.offHostSE = offHostSE;
            boolean success = writeDynamicSettingsLocked();
            if (!success) {
                Log.e(TAG, "Failed to persist AID group.");
                dynSettings.offHostSE = null;
                return false;
            }

            serviceInfo.setOffHostSecureElement(offHostSE);
            newServices = new ArrayList<NfcApduServiceInfo>(services.services.values());
        }
        // Make callback without the lock held
        mCallback.onServicesUpdated(userId, newServices);
        return true;
    }

    public boolean unsetOffHostSecureElement(int userId, int uid, ComponentName componentName) {
        ArrayList<NfcApduServiceInfo> newServices = null;
        synchronized (mLock) {
            UserServices services = findOrCreateUserLocked(userId);
            // Check if we can find this service
            NfcApduServiceInfo serviceInfo = getService(userId, componentName);
            if (serviceInfo == null) {
                Log.e(TAG, "Service " + componentName + " does not exist.");
                return false;
            }
            if (serviceInfo.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 (serviceInfo.isOnHost() || serviceInfo.getOffHostSecureElement() == null) {
                Log.e(TAG, "OffHostSE is not set");
                return false;
            }
            serviceInfo.unsetOffHostSecureElement();
            DynamicSettings dynSettings = services.dynamicSettings.get(componentName);
            if (dynSettings != null) {
              String offHostSE = dynSettings.offHostSE;
              dynSettings.offHostSE = serviceInfo.getOffHostSecureElement();
              boolean success = writeDynamicSettingsLocked();
              if (!success) {
                Log.e(TAG, "Failed to persist AID group.");
                dynSettings.offHostSE = offHostSE;
                return false;
              }
            }

            newServices = new ArrayList<NfcApduServiceInfo>(services.services.values());
        }
        // Make callback without the lock held
        mCallback.onServicesUpdated(userId, newServices);
        return true;
    }

    public boolean registerAidGroupForService(int userId, int uid,
            ComponentName componentName, NfcAidGroup nfcAidGroup) {
        ArrayList<NfcApduServiceInfo> newServices = null;
        boolean success;
        synchronized (mLock) {
            UserServices services = findOrCreateUserLocked(userId);
            // Check if we can find this service
            NfcApduServiceInfo serviceInfo = getService(userId, componentName);
            if (serviceInfo == null) {
                Log.e(TAG, "Service " + componentName + " does not exist.");
                return false;
            }
            if (serviceInfo.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;
            }
            // Do another AID validation, since a caller could have thrown in a modified
            // NfcAidGroup object with invalid AIDs over Binder.
            List<String> aids = nfcAidGroup.getAids();
            for (String aid : aids) {
                if (!CardEmulation.isValidAid(aid)) {
                    Log.e(TAG, "AID " + aid + " is not a valid AID");
                    return false;
                }
            }
            serviceInfo.setOrReplaceDynamicNfcAidGroup(nfcAidGroup);
            DynamicSettings dynSettings = services.dynamicSettings.get(componentName);
            if (dynSettings == null) {
                dynSettings = new DynamicSettings(uid);
                dynSettings.offHostSE = serviceInfo.getOffHostSecureElement();
                services.dynamicSettings.put(componentName, dynSettings);
            }
            dynSettings.aidGroups.put(nfcAidGroup.getCategory(), nfcAidGroup);
            success = writeDynamicSettingsLocked();
            if (success) {
                newServices = new ArrayList<NfcApduServiceInfo>(services.services.values());
            } else {
                Log.e(TAG, "Failed to persist AID group.");
                // Undo registration
                dynSettings.aidGroups.remove(nfcAidGroup.getCategory());
            }
        }
        if (success) {
            // Make callback without the lock held
            mCallback.onServicesUpdated(userId, newServices);
        }
        return success;
    }

    public NfcAidGroup getAidGroupForService(int userId, int uid, ComponentName componentName,
            String category) {
        NfcApduServiceInfo serviceInfo = getService(userId, componentName);
        if (serviceInfo != null) {
            if (serviceInfo.getUid() != uid) {
                Log.e(TAG, "UID mismatch");
                return null;
            }
            return serviceInfo.getDynamicNfcAidGroupForCategory(category);
        } else {
            Log.e(TAG, "Could not find service " + componentName);
            return null;
        }
    }

    public boolean removeAidGroupForService(int userId, int uid, ComponentName componentName,
            String category) {
        boolean success = false;
        ArrayList<NfcApduServiceInfo> newServices = null;
        synchronized (mLock) {
            UserServices services = findOrCreateUserLocked(userId);
            NfcApduServiceInfo serviceInfo = getService(userId, componentName);
            if (serviceInfo != null) {
                if (serviceInfo.getUid() != uid) {
                    // Calling from different uid
                    Log.e(TAG, "UID mismatch");
                    return false;
                }
                if (!serviceInfo.removeDynamicNfcAidGroupForCategory(category)) {
                    Log.e(TAG," Could not find dynamic AIDs for category " + category);
                    return false;
                }
                // Remove from local cache
                DynamicSettings dynAids = services.dynamicSettings.get(componentName);
                if (dynAids != null) {
                    NfcAidGroup deletedGroup = dynAids.aidGroups.remove(category);
                    success = writeDynamicSettingsLocked();
                    if (success) {
                        newServices = new ArrayList<NfcApduServiceInfo>(services.services.values());
                    } else {
                        Log.e(TAG, "Could not persist deleted AID group.");
                        dynAids.aidGroups.put(category, deletedGroup);
                        return false;
                    }
                } else {
                    Log.e(TAG, "Could not find aid group in local cache.");
                }
            } else {
                Log.e(TAG, "Service " + componentName + " does not exist.");
            }
        }
        if (success) {
            mCallback.onServicesUpdated(userId, newServices);
        }
        return success;
    }

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

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