NFC: Move NFC service implementation out of system_server.

NFC service is now an application service in packages/apps/Nfc.

NFC service is registered through ServiceManager.addService(), and the proxy
object NfcAdapter obtains a handle to it through ServiceManager.getService().

**Important** Had to add new symbols AID_NFC / NFC_UID / android.uid.nfc and
modify service_manager.c, Process.java and PackageManagerService.java in order
to force the com.android.nfc process to take a fixed uid, so that it can use
ServiceManager.addService().

Most of the JNI has moved to packages/apps/Nfc/jni. However NdefRecord and
NdefMessage require some in-process native code, so android_com_NdefMessage.cpp
and android_com_NdefRecord.cpp stay in frameworks/base/core/jni. They link to
a very small library libnfc_ndef.so that implements NDEF message parsing. This
has been added to core.mk so all devices (even without NFC hardware) can work
with NDEF data.

Bug: 3041259
Bug: 3097445
Change-Id: If8f00ce8f2053acfc9319ca366d4a9c02bd396e6
Signed-off-by: Nick Pelly <npelly@google.com>
diff --git a/cmds/servicemanager/service_manager.c b/cmds/servicemanager/service_manager.c
index 22d5b39..a5a1f01 100644
--- a/cmds/servicemanager/service_manager.c
+++ b/cmds/servicemanager/service_manager.c
@@ -34,6 +34,7 @@
     { AID_MEDIA, "media.player" },
     { AID_MEDIA, "media.camera" },
     { AID_MEDIA, "media.audio_policy" },
+    { AID_NFC,   "nfc" },
     { AID_RADIO, "radio.phone" },
     { AID_RADIO, "radio.sms" },
     { AID_RADIO, "radio.phonesubinfo" },
diff --git a/core/java/android/content/Context.java b/core/java/android/content/Context.java
index 693be21..0dd2e4a 100644
--- a/core/java/android/content/Context.java
+++ b/core/java/android/content/Context.java
@@ -1555,16 +1555,6 @@
     public static final String SIP_SERVICE = "sip";
 
     /**
-     * Use with {@link #getSystemService} to retrieve an
-     * {@link com.trustedlogic.trustednfc.android.INfcManager.INfcManager} for
-     * accessing NFC methods.
-     *
-     * @see #getSystemService
-     * @hide
-     */
-    public static final String NFC_SERVICE = "nfc";
-
-    /**
      * Determine whether the given permission is allowed for a particular
      * process and user ID running in the system.
      *
diff --git a/core/java/android/nfc/NfcAdapter.java b/core/java/android/nfc/NfcAdapter.java
index 02b9fb71..b916b34 100644
--- a/core/java/android/nfc/NfcAdapter.java
+++ b/core/java/android/nfc/NfcAdapter.java
@@ -166,10 +166,10 @@
             }
             sIsInitialized = true;
 
-            // TODO(npelly): check which method to use here to get the service
-            IBinder b = ServiceManager.getService(Context.NFC_SERVICE);
+            IBinder b = ServiceManager.getService("nfc");
             if (b == null) {
-                return null;  // This device does not have NFC
+                Log.d(TAG, "NFC Service not available");
+                return null;
             }
 
             sAdapter = new NfcAdapter(INfcAdapter.Stub.asInterface(b));
diff --git a/core/java/android/os/Process.java b/core/java/android/os/Process.java
index f695dbb..a718fc6 100644
--- a/core/java/android/os/Process.java
+++ b/core/java/android/os/Process.java
@@ -86,6 +86,12 @@
     public static final int WIFI_UID = 1010;
 
     /**
+     * Defines the UID/GID for the NFC service process.
+     * @hide
+     */
+    public static final int NFC_UID = 1022;
+
+    /**
      * Defines the start of a range of UIDs (and GIDs), going from this
      * number to {@link #LAST_APPLICATION_UID} that are reserved for assigning
      * to applications.
diff --git a/core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpConnectionlessSocket.java b/core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpConnectionlessSocket.java
deleted file mode 100644
index eff01b6..0000000
--- a/core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpConnectionlessSocket.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2010 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.
- */
-
-/**
- * File            : NativeLlcpConnectionLessSocket.java
- * Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
- * Created         : 18-02-2010
- */
-
-package com.trustedlogic.trustednfc.android.internal;
-
-import android.nfc.LlcpPacket;
-
-/**
- * LlcpConnectionlessSocket represents a LLCP Connectionless object to be used
- * in a connectionless communication
- *
- * @since AA02.01
- * @hide
- */
-
-public class NativeLlcpConnectionlessSocket {
-
-    private int mHandle;
-
-    private int mSap;
-
-    private int mLinkMiu;
-
-    public NativeLlcpConnectionlessSocket(){;
-    }
-
-    public NativeLlcpConnectionlessSocket(int sap){
-        mSap = sap;
-    }
-
-    public native boolean doSendTo(int sap, byte[] data);
-
-    public native LlcpPacket doReceiveFrom(int linkMiu);
-
-    public native boolean doClose();
-
-    public int getLinkMiu(){
-        return mLinkMiu;
-    }
-
-    public int getSap(){
-        return mSap;
-    }
-
-    public int getHandle(){
-        return mHandle;
-    }
-
-}
diff --git a/core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpServiceSocket.java b/core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpServiceSocket.java
deleted file mode 100644
index 079d69b..0000000
--- a/core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpServiceSocket.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (C) 2010 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.
- */
-
-/**
- * File            : NativeLlcpServerSocket.java
- * Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
- * Created         : 18-02-2010
- */
-
-package com.trustedlogic.trustednfc.android.internal;
-
-/**
- * LlcpServiceSocket represents a LLCP Service to be used in a
- * Connection-oriented communication
- * {@hide}
- */
-
-public class NativeLlcpServiceSocket {
-
-    private int mHandle;
-
-    private int mLocalMiu;
-
-    private int mLocalRw;
-
-    private int mLocalLinearBufferLength;
-
-    private int mSap;
-
-    private int mTimeout;
-
-    private String mServiceName;
-
-    public NativeLlcpServiceSocket(){
-
-    }
-
-    public NativeLlcpServiceSocket(String serviceName){
-        mServiceName = serviceName;
-    }
-
-    public native NativeLlcpSocket doAccept(int timeout, int miu, int rw, int linearBufferLength);
-
-    public native boolean doClose();
-
-    public int getHandle(){
-        return mHandle;
-    }
-
-    public void setAcceptTimeout(int timeout){
-        mTimeout = timeout;
-    }
-
-    public int getAcceptTimeout(){
-        return mTimeout;
-    }
-
-    public int getRw(){
-        return mLocalRw;
-    }
-
-    public int getMiu(){
-        return mLocalMiu;
-    }
-
-    public int getLinearBufferLength(){
-        return mLocalLinearBufferLength;
-    }
-}
diff --git a/core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpSocket.java b/core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpSocket.java
deleted file mode 100644
index 818cfaa..0000000
--- a/core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpSocket.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright (C) 2010 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.
- */
-
-/**
- * File            : NativeLlcpClientSocket.java
- * Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
- * Created         : 18-02-2010
- */
-
-package com.trustedlogic.trustednfc.android.internal;
-
-/**
- * LlcpClientSocket represents a LLCP Connection-Oriented client to be used in a
- * connection-oriented communication
- * @hide
- */
-
-public class NativeLlcpSocket {
-
-    private int mHandle;
-
-    private int mSap;
-
-    private int mLocalMiu;
-
-    private int mLocalRw;
-
-    private int mTimeout;
-
-    public NativeLlcpSocket(){
-
-    }
-
-    public NativeLlcpSocket(int sap, int miu, int rw){
-        mSap = sap;
-        mLocalMiu = miu;
-        mLocalRw = rw;
-    }
-
-    public native boolean doConnect(int nSap, int timeout);
-
-    public native boolean doConnectBy(String sn, int timeout);
-
-    public native boolean doClose();
-
-    public native boolean doSend(byte[] data);
-
-    public native int doReceive(byte[] recvBuff);
-
-    public native int doGetRemoteSocketMiu();
-
-    public native int doGetRemoteSocketRw();
-
-
-
-    public void setConnectTimeout(int timeout){
-        mTimeout = timeout;
-    }
-
-    public int getConnectTimeout(){
-        return mTimeout;
-    }
-
-    public int getSap(){
-        return mSap;
-    }
-
-    public int getMiu(){
-        return mLocalMiu;
-    }
-
-    public int getRw(){
-        return mLocalRw;
-    }
-
-    public int getHandle(){
-        return mHandle;
-    }
-
-}
diff --git a/core/java/com/trustedlogic/trustednfc/android/internal/NativeNdefTag.java b/core/java/com/trustedlogic/trustednfc/android/internal/NativeNdefTag.java
deleted file mode 100644
index 819b039..0000000
--- a/core/java/com/trustedlogic/trustednfc/android/internal/NativeNdefTag.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (C) 2010 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.
- */
-
-/**
- * File            : NativeNdefTag.java
- * Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
- * Created         : 18-02-2010
- */
-
-package com.trustedlogic.trustednfc.android.internal;
-
-/**
- * Native interface to the NDEF tag functions
- *
- * @hide
- */
-public class NativeNdefTag {
-    private int mHandle;
-
-    public native byte[] doRead();
-
-    public native boolean doWrite(byte[] buf);
-}
diff --git a/core/java/com/trustedlogic/trustednfc/android/internal/NativeNfcManager.java b/core/java/com/trustedlogic/trustednfc/android/internal/NativeNfcManager.java
deleted file mode 100644
index 5ff348a..0000000
--- a/core/java/com/trustedlogic/trustednfc/android/internal/NativeNfcManager.java
+++ /dev/null
@@ -1,369 +0,0 @@
-/*
- * Copyright (C) 2010 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.
- */
-
-/**
- * File            : NativeNfcManager.java
- * Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
- * Created         : 18-02-2010
- */
-
-package com.trustedlogic.trustednfc.android.internal;
-
-import android.annotation.SdkConstant;
-import android.annotation.SdkConstant.SdkConstantType;
-import android.content.ActivityNotFoundException;
-import android.content.Context;
-import android.content.Intent;
-import android.os.Handler;
-import android.os.Message;
-import android.util.Log;
-
-import android.nfc.FormatException;
-import android.nfc.NdefTag;
-import android.nfc.NfcAdapter;
-import android.nfc.NdefMessage;
-import android.nfc.Tag;
-
-/**
- * Native interface to the NFC Manager functions
- * @hide
- */
-public class NativeNfcManager {
-
-    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
-    public static final String INTERNAL_LLCP_LINK_STATE_CHANGED_EXTRA = "com.trustedlogic.trustednfc.android.extra.INTERNAL_LLCP_LINK_STATE";
-
-    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
-    public static final String INTERNAL_LLCP_LINK_STATE_CHANGED_ACTION = "com.trustedlogic.trustednfc.android.action.INTERNAL_LLCP_LINK_STATE_CHANGED";
-
-    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
-    public static final String INTERNAL_TARGET_DESELECTED_ACTION = "com.trustedlogic.trustednfc.android.action.INTERNAL_TARGET_DESELECTED";
-
-    /* Native structure */
-    private int mNative;
-
-    private final Context mContext;
-
-    private final Handler mNfcHandler;
-
-    private static final String TAG = "NativeNfcManager";
-
-    private static final int MSG_NDEF_TAG = 0;
-
-    private static final int MSG_CARD_EMULATION = 1;
-
-    private static final int MSG_LLCP_LINK_ACTIVATION = 2;
-
-    private static final int MSG_LLCP_LINK_DEACTIVATED = 3;
-
-    private static final int MSG_TARGET_DESELECTED = 4;
-
-    public NativeNfcManager(Context context) {
-        mNfcHandler = new NfcHandler();
-        mContext = context;
-    }
-
-    /**
-     * Initializes Native structure
-     */
-    public native boolean initializeNativeStructure();
-
-    /**
-     * Initializes NFC stack.
-     */
-    public native boolean initialize();
-
-    /**
-     * Deinitializes NFC stack.
-     */
-    public native boolean deinitialize();
-
-    /**
-     * Enable discory for the NdefMessage and Transaction notification
-     */
-    public native void enableDiscovery(int mode);
-
-    public native void disableDiscovery();
-
-    public native void readerDiscovery();
-
-    /**
-     * Disables an NFCManager mode of operation. Allows to disable tag reader,
-     * peer to peer initiator or target modes.
-     *
-     * @param mode discovery mode to enable. Must be one of the provided
-     *            NFCManager.DISCOVERY_MODE_* constants.
-     */
-    public native void disableDiscoveryMode(int mode);
-
-    public native int[] doGetSecureElementList();
-
-    public native void doSelectSecureElement(int seID);
-
-    public native void doDeselectSecureElement(int seID);
-
-    public native NativeP2pDevice doOpenP2pConnection(int timeout);
-
-    public native NativeNfcTag doOpenTagConnection(int timeout);
-
-    public native int doGetLastError();
-
-    public native void doSetProperties(int param, int value);
-
-    public native void doCancel();
-
-    public native NativeLlcpConnectionlessSocket doCreateLlcpConnectionlessSocket(int nSap);
-
-    public native NativeLlcpServiceSocket doCreateLlcpServiceSocket(int nSap, String sn, int miu,
-            int rw, int linearBufferLength);
-
-    public native NativeLlcpSocket doCreateLlcpSocket(int sap, int miu, int rw,
-            int linearBufferLength);
-
-    public native boolean doCheckLlcp();
-
-    public native boolean doActivateLlcp();
-
-    private class NfcHandler extends Handler {
-
-        private int convertType(String typeName) {
-            if (typeName.equals("Iso14443")) {
-                return Tag.NFC_TAG_ISO14443_4B;
-            } else if (typeName.equals("MifareUL")) {
-                return Tag.NFC_TAG_MIFARE;
-            } else if (typeName.equals("Mifare1K")) {
-                return Tag.NFC_TAG_MIFARE;
-            } else if (typeName.equals("Mifare4K")) {
-                return Tag.NFC_TAG_MIFARE;
-            } else if (typeName.equals("MifareDESFIRE")) {
-                return Tag.NFC_TAG_MIFARE;
-            } else if (typeName.equals("Unknown Mifare")) {
-                return Tag.NFC_TAG_MIFARE;
-            } else if (typeName.equals("Felica")) {
-                return Tag.NFC_TAG_FELICA;
-            } else if (typeName.equals("Jewel")) {
-                return Tag.NFC_TAG_JEWEL;
-            } else {
-                return Tag.NFC_TAG_OTHER;
-            }
-        }
-
-        @Override
-        public void handleMessage(Message msg) {
-
-            try {
-                switch (msg.what) {
-                    case MSG_NDEF_TAG:
-                        Log.d(TAG, "Tag detected, notifying applications");
-                        NativeNfcTag nativeTag = (NativeNfcTag) msg.obj;
-                        if (nativeTag.doConnect()) {
-                            if (nativeTag.checkNDEF()) {
-                                byte[] buff = nativeTag.doRead();
-                                if (buff != null) {
-                                    NdefMessage[] msgNdef = new NdefMessage[1];
-                                    try {
-                                        msgNdef[0] = new NdefMessage(buff);
-                                        NdefTag tag = new NdefTag(convertType(nativeTag.getType()), nativeTag.getUid(), nativeTag.getHandle(), msgNdef);
-                                        Intent intent = new Intent();
-                                        intent.setAction(NfcAdapter.ACTION_NDEF_TAG_DISCOVERED);
-                                        intent.putExtra(NfcAdapter.EXTRA_TAG, tag);
-                                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-                                        Log.d(TAG, "NDEF tag found, starting corresponding activity");
-                                        try {
-                                            mContext.startActivity(intent);
-                                        } catch (ActivityNotFoundException e) {
-                                            Log.w(TAG, "No activity found, disconnecting");
-                                            nativeTag.doAsyncDisconnect();
-                                        }
-                                    } catch (FormatException e) {
-                                        Log.w(TAG, "Unable to create NDEF message object (tag empty or not well formated)");
-                                        nativeTag.doAsyncDisconnect();
-                                    }
-                                } else {
-                                    Log.w(TAG, "Unable to read NDEF message (tag empty or not well formated)");
-                                    nativeTag.doAsyncDisconnect();
-                                }
-                            } else {
-                                Intent intent = new Intent();
-                                Tag tag = new Tag(convertType(nativeTag.getType()), false, nativeTag.getUid(), nativeTag.getHandle());
-                                intent.setAction(NfcAdapter.ACTION_TAG_DISCOVERED);
-                                intent.putExtra(NfcAdapter.EXTRA_TAG, tag);
-                                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-                                Log.d(TAG, "Non-NDEF tag found, starting corresponding activity");
-                                try {
-                                    mContext.startActivity(intent);
-                                } catch (ActivityNotFoundException e) {
-                                    Log.w(TAG, "No activity found, disconnecting");
-                                    nativeTag.doAsyncDisconnect();
-                                }
-                            }
-                        } else {
-                            Log.w(TAG, "Failed to connect to tag");
-                            nativeTag.doAsyncDisconnect();
-                        }
-                        break;
-                    case MSG_CARD_EMULATION:
-                        Log.d(TAG, "Card Emulation message");
-                        byte[] aid = (byte[]) msg.obj;
-                        /* Send broadcast ordered */
-                        Intent TransactionIntent = new Intent();
-                        TransactionIntent.setAction(NfcAdapter.ACTION_TRANSACTION_DETECTED);
-                        TransactionIntent.putExtra(NfcAdapter.EXTRA_AID, aid);
-                        Log.d(TAG, "Broadcasting Card Emulation event");
-                        mContext.sendOrderedBroadcast(TransactionIntent,
-                                android.Manifest.permission.NFC_NOTIFY);
-                        break;
-
-                    case MSG_LLCP_LINK_ACTIVATION:
-                        NativeP2pDevice device = (NativeP2pDevice) msg.obj;
-
-                        Log.d(TAG, "LLCP Activation message");
-
-                        if (device.getMode() == NativeP2pDevice.MODE_P2P_TARGET) {
-                            if (device.doConnect()) {
-                                /* Check Llcp compliancy */
-                                if (doCheckLlcp()) {
-                                    /* Activate Llcp Link */
-                                    if (doActivateLlcp()) {
-                                        Log.d(TAG, "Initiator Activate LLCP OK");
-                                        /* Broadcast Intent Link LLCP activated */
-                                        Intent LlcpLinkIntent = new Intent();
-                                        LlcpLinkIntent
-                                                .setAction(INTERNAL_LLCP_LINK_STATE_CHANGED_ACTION);
-                                        LlcpLinkIntent.putExtra(
-                                                INTERNAL_LLCP_LINK_STATE_CHANGED_EXTRA,
-                                                NfcAdapter.LLCP_LINK_STATE_ACTIVATED);
-                                        Log.d(TAG, "Broadcasting internal LLCP activation");
-                                        mContext.sendBroadcast(LlcpLinkIntent);
-                                    }
-
-                                } else {
-                                    device.doDisconnect();
-                                }
-
-                            }
-
-                        } else if (device.getMode() == NativeP2pDevice.MODE_P2P_INITIATOR) {
-                            /* Check Llcp compliancy */
-                            if (doCheckLlcp()) {
-                                /* Activate Llcp Link */
-                                if (doActivateLlcp()) {
-                                    Log.d(TAG, "Target Activate LLCP OK");
-                                    /* Broadcast Intent Link LLCP activated */
-                                    Intent LlcpLinkIntent = new Intent();
-                                    LlcpLinkIntent
-                                            .setAction(INTERNAL_LLCP_LINK_STATE_CHANGED_ACTION);
-                                    LlcpLinkIntent.putExtra(INTERNAL_LLCP_LINK_STATE_CHANGED_EXTRA,
-                                            NfcAdapter.LLCP_LINK_STATE_ACTIVATED);
-                                    Log.d(TAG, "Broadcasting internal LLCP activation");
-                                    mContext.sendBroadcast(LlcpLinkIntent);
-                                }
-                            }
-                        }
-                        break;
-
-                    case MSG_LLCP_LINK_DEACTIVATED:
-                        /* Broadcast Intent Link LLCP activated */
-                        Log.d(TAG, "LLCP Link Deactivated message");
-                        Intent LlcpLinkIntent = new Intent();
-                        LlcpLinkIntent.setAction(NfcAdapter.ACTION_LLCP_LINK_STATE_CHANGED);
-                        LlcpLinkIntent.putExtra(NfcAdapter.EXTRA_LLCP_LINK_STATE_CHANGED,
-                                NfcAdapter.LLCP_LINK_STATE_DEACTIVATED);
-                        Log.d(TAG, "Broadcasting LLCP deactivation");
-                        mContext.sendOrderedBroadcast(LlcpLinkIntent,
-                                android.Manifest.permission.NFC_LLCP);
-                        break;
-
-                    case MSG_TARGET_DESELECTED:
-                        /* Broadcast Intent Target Deselected */
-                        Log.d(TAG, "Target Deselected");
-                        Intent TargetDeselectedIntent = new Intent();
-                        TargetDeselectedIntent.setAction(INTERNAL_TARGET_DESELECTED_ACTION);
-                        Log.d(TAG, "Broadcasting Intent");
-                        mContext.sendOrderedBroadcast(TargetDeselectedIntent,
-                                android.Manifest.permission.NFC_LLCP);
-                        break;
-
-                    default:
-                        Log.e(TAG, "Unknown message received");
-                        break;
-                }
-            } catch (Exception e) {
-                // Log, don't crash!
-                Log.e(TAG, "Exception in NfcHandler.handleMessage:", e);
-            }
-        }
-    };
-
-    /**
-     * Notifies Ndef Message
-     */
-    private void notifyNdefMessageListeners(NativeNfcTag tag) {
-        Message msg = mNfcHandler.obtainMessage();
-
-        msg.what = MSG_NDEF_TAG;
-        msg.obj = tag;
-
-        mNfcHandler.sendMessage(msg);
-    }
-
-    /**
-     * Notifies transaction
-     */
-    private void notifyTargetDeselected() {
-        Message msg = mNfcHandler.obtainMessage();
-
-        msg.what = MSG_TARGET_DESELECTED;
-
-        mNfcHandler.sendMessage(msg);
-    }
-
-    /**
-     * Notifies transaction
-     */
-    private void notifyTransactionListeners(byte[] aid) {
-        Message msg = mNfcHandler.obtainMessage();
-
-        msg.what = MSG_CARD_EMULATION;
-        msg.obj = aid;
-
-        mNfcHandler.sendMessage(msg);
-    }
-
-    /**
-     * Notifies P2P Device detected, to activate LLCP link
-     */
-    private void notifyLlcpLinkActivation(NativeP2pDevice device) {
-        Message msg = mNfcHandler.obtainMessage();
-
-        msg.what = MSG_LLCP_LINK_ACTIVATION;
-        msg.obj = device;
-
-        mNfcHandler.sendMessage(msg);
-    }
-
-    /**
-     * Notifies P2P Device detected, to activate LLCP link
-     */
-    private void notifyLlcpLinkDeactivated() {
-        Message msg = mNfcHandler.obtainMessage();
-
-        msg.what = MSG_LLCP_LINK_DEACTIVATED;
-
-        mNfcHandler.sendMessage(msg);
-    }
-
-}
diff --git a/core/java/com/trustedlogic/trustednfc/android/internal/NativeNfcTag.java b/core/java/com/trustedlogic/trustednfc/android/internal/NativeNfcTag.java
deleted file mode 100644
index 47cf45b..0000000
--- a/core/java/com/trustedlogic/trustednfc/android/internal/NativeNfcTag.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2010 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.
- */
-
-/**
- * File            : NativeNfcTag.java
- * Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
- * Created         : 18-02-2010
- */
-
-package com.trustedlogic.trustednfc.android.internal;
-
-/**
- * Native interface to the NFC tag functions
- *
- * @hide
- */
-public class NativeNfcTag {
-    private int mHandle;
-
-    private String mType;
-
-    private byte[] mUid;
-
-    public native boolean doConnect();
-
-    public native boolean doDisconnect();
-
-    public native void doAsyncDisconnect();
-
-    public native byte[] doTransceive(byte[] data);
-
-    public native boolean checkNDEF();
-
-    public native byte[] doRead();
-
-    public native boolean doWrite(byte[] buf);
-
-    private NativeNfcTag() {
-    }
-
-    public NativeNfcTag(int handle, String type, byte[] uid) {
-        mHandle = handle;
-        mType = type;
-        mUid = uid.clone();
-    }
-
-    public int getHandle() {
-        return mHandle;
-    }
-
-    public String getType() {
-        return mType;
-    }
-
-    public byte[] getUid() {
-        return mUid;
-    }
-}
diff --git a/core/java/com/trustedlogic/trustednfc/android/internal/NativeP2pDevice.java b/core/java/com/trustedlogic/trustednfc/android/internal/NativeP2pDevice.java
deleted file mode 100644
index c674309..0000000
--- a/core/java/com/trustedlogic/trustednfc/android/internal/NativeP2pDevice.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (C) 2010 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.
- */
-
-/**
- * File            : NativeP2pDevice.java
- * Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
- * Created         : 18-02-2010
- */
-
-package com.trustedlogic.trustednfc.android.internal;
-
-/**
- * Native interface to the P2P Initiator functions
- *
- * @hide
- */
-public class NativeP2pDevice {
-
-    /**
-    * Peer-to-Peer Target.
-    */
-    public static final short MODE_P2P_TARGET          = 0x00;
-
-    /**
-    * Peer-to-Peer Initiator.
-    */
-    public static final short MODE_P2P_INITIATOR       = 0x01;
-
-    /**
-    * Invalid target type.
-    */
-    public static final short MODE_INVALID             = 0xff;
-
-    private int mHandle;
-
-    private int mMode;
-
-    private byte[] mGeneralBytes;
-
-    public native byte[] doReceive();
-
-    public native boolean doSend(byte[] data);
-
-    public native boolean doConnect();
-
-    public native boolean doDisconnect();
-
-    public native byte[] doTransceive(byte[] data);
-
-    public int getHandle() {
-        return mHandle;
-    }
-
-    public int getMode() {
-        return mMode;
-    }
-
-    public byte[] getGeneralBytes() {
-        return mGeneralBytes;
-    }
-
-}
diff --git a/core/jni/Android.mk b/core/jni/Android.mk
index d51c0b7..c3f393d 100644
--- a/core/jni/Android.mk
+++ b/core/jni/Android.mk
@@ -67,6 +67,8 @@
 	android_net_TrafficStats.cpp \
 	android_net_wifi_Wifi.cpp \
 	android_nio_utils.cpp \
+	android_nfc_NdefMessage.cpp \
+	android_nfc_NdefRecord.cpp \
 	android_pim_EventRecurrence.cpp \
 	android_text_format_Time.cpp \
 	android_security_Md5MessageDigest.cpp \
@@ -190,15 +192,8 @@
 	libicui18n \
 	libmedia \
 	libwpa_client \
-	libjpeg
-
-ifeq ($(BOARD_HAVE_NFC),true)
-LOCAL_SHARED_LIBRARIES += \
-	libnfc_jni \
-	libnfc
-
-LOCAL_CFLAGS += -DHAVE_NFC
-endif
+	libjpeg \
+	libnfc_ndef
 
 ifeq ($(BOARD_HAVE_BLUETOOTH),true)
 LOCAL_C_INCLUDES += \
diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp
index 5f73443..648d93f 100644
--- a/core/jni/AndroidRuntime.cpp
+++ b/core/jni/AndroidRuntime.cpp
@@ -125,6 +125,8 @@
 extern int register_android_database_SQLiteStatement(JNIEnv* env);
 extern int register_android_debug_JNITest(JNIEnv* env);
 extern int register_android_nio_utils(JNIEnv* env);
+extern int register_android_nfc_NdefMessage(JNIEnv *env);
+extern int register_android_nfc_NdefRecord(JNIEnv *env);
 extern int register_android_pim_EventRecurrence(JNIEnv* env);
 extern int register_android_text_format_Time(JNIEnv* env);
 extern int register_android_os_Debug(JNIEnv* env);
@@ -169,18 +171,6 @@
 extern int register_android_content_res_ObbScanner(JNIEnv* env);
 extern int register_android_content_res_Configuration(JNIEnv* env);
 
-#ifdef HAVE_NFC
-extern int register_com_trustedlogic_trustednfc_android_internal_NativeNfcManager(JNIEnv *env);
-extern int register_com_trustedlogic_trustednfc_android_internal_NativeNfcTag(JNIEnv *env);
-extern int register_com_trustedlogic_trustednfc_android_internal_NativeNdefTag(JNIEnv *env);
-extern int register_com_trustedlogic_trustednfc_android_NdefMessage(JNIEnv *env);
-extern int register_com_trustedlogic_trustednfc_android_NdefRecord(JNIEnv *env);
-extern int register_com_trustedlogic_trustednfc_android_internal_NativeP2pDevice(JNIEnv *env);
-extern int register_com_trustedlogic_trustednfc_android_internal_NativeLlcpSocket(JNIEnv *env);
-extern int register_com_trustedlogic_trustednfc_android_internal_NativeLlcpConnectionlessSocket(JNIEnv *env);
-extern int register_com_trustedlogic_trustednfc_android_internal_NativeLlcpServiceSocket(JNIEnv *env);
-#endif
-
 static AndroidRuntime* gCurRuntime = NULL;
 
 static void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL)
@@ -1263,6 +1253,8 @@
     REG_JNI(register_android_net_NetworkUtils),
     REG_JNI(register_android_net_TrafficStats),
     REG_JNI(register_android_net_wifi_WifiManager),
+    REG_JNI(register_android_nfc_NdefMessage),
+    REG_JNI(register_android_nfc_NdefRecord),
     REG_JNI(register_android_os_MemoryFile),
     REG_JNI(register_com_android_internal_os_ZygoteInit),
     REG_JNI(register_android_hardware_Camera),
@@ -1297,18 +1289,6 @@
 
     REG_JNI(register_android_content_res_ObbScanner),
     REG_JNI(register_android_content_res_Configuration),
-
-#ifdef HAVE_NFC
-    REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeNfcManager),
-    REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeNfcTag),
-    REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeNdefTag),
-    REG_JNI(register_com_trustedlogic_trustednfc_android_NdefMessage),
-    REG_JNI(register_com_trustedlogic_trustednfc_android_NdefRecord),
-    REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeP2pDevice),
-    REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeLlcpSocket),
-    REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeLlcpConnectionlessSocket),
-    REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeLlcpServiceSocket),
-#endif
 };
 
 /*
diff --git a/core/jni/android_nfc.h b/core/jni/android_nfc.h
new file mode 100644
index 0000000..df660f2
--- /dev/null
+++ b/core/jni/android_nfc.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+/*
+ * Contains the bare minimum header so that framework NFC jni can link
+ * against NFC native library
+ */
+
+#ifndef __ANDROID_NFC_H__
+#define __ANDROID_NFC_H__
+
+extern "C" {
+
+typedef struct phFriNfc_NdefRecord {
+    uint8_t                 Flags;
+    uint8_t                 Tnf;
+    uint8_t                 TypeLength;
+    uint8_t                *Type;
+    uint8_t                 IdLength;
+    uint8_t                *Id;
+    uint32_t                PayloadLength;
+    uint8_t                *PayloadData;
+} phFriNfc_NdefRecord_t;
+
+uint16_t phFriNfc_NdefRecord_GetRecords(uint8_t*      pBuffer,
+                                        uint32_t      BufferLength,
+                                        uint8_t*      pRawRecords[ ],
+                                        uint8_t       IsChunked[ ],
+                                        uint32_t*     pNumberOfRawRecords
+                                        );
+uint16_t phFriNfc_NdefRecord_Parse(phFriNfc_NdefRecord_t* pRecord,
+                                   uint8_t*               pRawRecord);
+
+uint16_t phFriNfc_NdefRecord_Generate(phFriNfc_NdefRecord_t*  pRecord,
+                                      uint8_t*                pBuffer,
+                                      uint32_t                MaxBufferSize,
+                                      uint32_t*               pBytesWritten
+                                      );
+}
+
+#endif
diff --git a/core/jni/android_nfc_NdefMessage.cpp b/core/jni/android_nfc_NdefMessage.cpp
new file mode 100644
index 0000000..99295f4
--- /dev/null
+++ b/core/jni/android_nfc_NdefMessage.cpp
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#define LOG_TAG "NdefMessage"
+
+#include "jni.h"
+#include "JNIHelp.h"
+
+#include "android_nfc.h"
+
+#include <utils/Log.h>
+
+namespace android {
+
+static jint android_nfc_NdefMessage_parseNdefMessage(JNIEnv *e, jobject o,
+        jbyteArray array)
+{
+    uint16_t status;
+    uint32_t i;
+    jbyte *raw_msg;
+    jsize raw_msg_size;
+    uint32_t num_of_records = 0;
+    uint8_t **records = NULL;
+    uint8_t *is_chunked = NULL;
+    jint ret = -1;
+    phFriNfc_NdefRecord_t record;
+
+    jclass record_cls;
+    jobjectArray records_array;
+    jmethodID ctor;
+
+    jclass msg_cls;
+    jfieldID mrecords;
+
+    raw_msg_size = e->GetArrayLength(array);
+    raw_msg = e->GetByteArrayElements(array, NULL);
+    if (raw_msg == NULL)
+        return -1;
+
+    /* Get the number of records in the message so we can allocate buffers */
+    LOGD("phFriNfc_NdefRecord_GetRecords(NULL)");
+
+    status = phFriNfc_NdefRecord_GetRecords((uint8_t *)raw_msg,
+            (uint32_t)raw_msg_size, NULL, NULL, &num_of_records);
+
+    if (status) {
+        LOGE("phFriNfc_NdefRecord_GetRecords(NULL) returned 0x%04x", status);
+        goto end;
+    }
+    LOGD("phFriNfc_NdefRecord_GetRecords(NULL) returned 0x%04x", status);
+
+    LOGD("found %d records in message", num_of_records);
+
+    is_chunked = (uint8_t*)malloc(num_of_records);
+    if (is_chunked == NULL)
+        goto end;
+    records = (uint8_t**)malloc(num_of_records * sizeof(uint8_t *));
+    if (records == NULL)
+        goto end;
+
+    /* Now, actually retrieve records position in message */
+    LOGD("phFriNfc_NdefRecord_GetRecords()");
+
+    status = phFriNfc_NdefRecord_GetRecords((uint8_t *)raw_msg,
+            (uint32_t)raw_msg_size, records, is_chunked, &num_of_records);
+
+    if (status) {
+        LOGE("phFriNfc_NdefRecord_GetRecords() returned 0x%04x", status);
+        goto end;
+    }
+    LOGD("phFriNfc_NdefRecord_GetRecords() returned 0x%04x", status);
+
+    /* Build NDEF records array */
+    record_cls = e->FindClass("android/nfc/NdefRecord");
+    records_array = e->NewObjectArray((jsize)num_of_records, record_cls,
+            NULL);
+    if (records_array == NULL)
+        goto end;
+
+    ctor = e->GetMethodID(record_cls, "<init>", "(S[B[B[B)V");
+
+    LOGD("NFC_Number of records = %d\n", num_of_records);
+
+    for (i = 0; i < num_of_records; i++) {
+        jbyteArray type, id, payload;
+        jobject new_record;
+
+        LOGD("phFriNfc_NdefRecord_Parse()");
+
+        status = phFriNfc_NdefRecord_Parse(&record, records[i]);
+
+        if (status) {
+            LOGE("phFriNfc_NdefRecord_Parse() returned 0x%04x", status);
+            goto end;
+        }
+        LOGD("phFriNfc_NdefRecord_Parse() returned 0x%04x", status);
+
+        type = e->NewByteArray(record.TypeLength);
+        if (type == NULL) {
+            LOGD("NFC_Set Record Type Error\n");
+            goto end;
+        }
+
+        id = e->NewByteArray(record.IdLength);
+        if(id == NULL) {
+            LOGD("NFC_Set Record ID Error\n");
+            goto end;
+        }
+
+        payload = e->NewByteArray(record.PayloadLength);
+        if(payload == NULL) {
+            LOGD("NFC_Set Record Payload Error\n");
+            goto end;
+        }
+
+        e->SetByteArrayRegion(type, 0, record.TypeLength,
+                (jbyte *)record.Type);
+        e->SetByteArrayRegion(id, 0, record.IdLength,
+                (jbyte *)record.Id);
+        e->SetByteArrayRegion(payload, 0, record.PayloadLength,
+                (jbyte *)record.PayloadData);
+
+        new_record = e->NewObject(record_cls, ctor,
+                (jshort)record.Tnf, type, id, payload);
+
+        e->SetObjectArrayElement(records_array, i, new_record);
+
+        /* Try not to clutter the Java stack too much */
+        e->DeleteLocalRef(new_record);
+        e->DeleteLocalRef(type);
+        e->DeleteLocalRef(id);
+        e->DeleteLocalRef(payload);
+    }
+
+    /* Store built array in our NDEFMessage instance */
+    msg_cls = e->GetObjectClass(o);
+    mrecords = e->GetFieldID(msg_cls, "mRecords", "[Landroid/nfc/NdefRecord;");
+
+    e->SetObjectField(o, mrecords, (jobject)records_array);
+
+    ret = 0;
+
+end:
+    if(is_chunked)
+        free(is_chunked);
+    if(records)
+        free(records);
+    e->ReleaseByteArrayElements(array, raw_msg, JNI_ABORT);
+
+    return ret;
+}
+
+static JNINativeMethod gMethods[] = {
+        {"parseNdefMessage", "([B)I", (void *)android_nfc_NdefMessage_parseNdefMessage},
+};
+
+int register_android_nfc_NdefMessage(JNIEnv *e)
+{
+    return jniRegisterNativeMethods(e, "android/nfc/NdefMessage", gMethods, NELEM(gMethods));
+}
+
+} // namespace android
diff --git a/core/jni/android_nfc_NdefRecord.cpp b/core/jni/android_nfc_NdefRecord.cpp
new file mode 100644
index 0000000..8ce1837
--- /dev/null
+++ b/core/jni/android_nfc_NdefRecord.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#define LOG_TAG "NdefRecord"
+
+#include "jni.h"
+#include "JNIHelp.h"
+
+#include "android_nfc.h"
+
+#include <utils/Log.h>
+
+namespace android {
+
+static jbyteArray android_nfc_NdefRecord_generate(
+        JNIEnv *e, jobject o, jshort flags, jshort tnf, jbyteArray type,
+        jbyteArray id, jbyteArray payload)
+{
+    uint32_t status;
+    phFriNfc_NdefRecord_t record;
+    uint32_t buf_size;
+    uint32_t record_size;
+    uint8_t *buf = NULL;
+    jbyteArray result = NULL;
+
+    /* Prepare NDEF record structure */
+    record.Flags = (uint8_t)flags;
+    record.Tnf = (uint8_t)tnf;
+    record.TypeLength = (uint32_t)e->GetArrayLength(type);
+    record.Type = (uint8_t *)e->GetByteArrayElements(type, NULL);
+    record.IdLength = (uint32_t)e->GetArrayLength(id);
+    record.Id = (uint8_t *)e->GetByteArrayElements(id, NULL);
+    record.PayloadLength = (uint32_t)e->GetArrayLength(payload);
+    record.PayloadData = (uint8_t *)e->GetByteArrayElements(payload, NULL);
+
+    buf_size = record.PayloadLength + record.IdLength + record.TypeLength + 8;
+
+    buf = (uint8_t*)malloc(buf_size);
+    if (buf == NULL)
+        goto end;
+
+    LOGD("phFriNfc_NdefRecord_Generate()");
+
+    status = phFriNfc_NdefRecord_Generate(&record, buf, buf_size,
+            &record_size);
+
+    if (status) {
+        LOGE("phFriNfc_NdefRecord_Generate() returned 0x%04x", status);
+        goto end;
+    }
+    LOGD("phFriNfc_NdefRecord_Generate() returned 0x%04x", status);
+
+    result = e->NewByteArray(record_size);
+    if (result == NULL)
+        goto end;
+
+    e->SetByteArrayRegion(result, 0, record_size, (jbyte *)buf);
+
+end:
+    e->ReleaseByteArrayElements(type, (jbyte *)record.Type, JNI_ABORT);
+    e->ReleaseByteArrayElements(id, (jbyte *)record.Id, JNI_ABORT);
+    e->ReleaseByteArrayElements(payload, (jbyte *)record.PayloadData, JNI_ABORT);
+
+    if(buf)
+        free(buf);
+
+    return result;
+}
+
+static JNINativeMethod gMethods[] = {
+    {"generate", "(SS[B[B[B)[B", (void *)android_nfc_NdefRecord_generate},
+};
+
+int register_android_nfc_NdefRecord(JNIEnv *e)
+{
+    return jniRegisterNativeMethods(e, "android/nfc/NdefRecord", gMethods, NELEM(gMethods));
+}
+
+} // namespace android
diff --git a/services/java/com/android/server/PackageManagerService.java b/services/java/com/android/server/PackageManagerService.java
index 9d7c58e..da95b97 100644
--- a/services/java/com/android/server/PackageManagerService.java
+++ b/services/java/com/android/server/PackageManagerService.java
@@ -144,6 +144,7 @@
     private static final boolean MULTIPLE_APPLICATION_UIDS = true;
     private static final int RADIO_UID = Process.PHONE_UID;
     private static final int LOG_UID = Process.LOG_UID;
+    private static final int NFC_UID = Process.NFC_UID;
     private static final int FIRST_APPLICATION_UID =
         Process.FIRST_APPLICATION_UID;
     private static final int MAX_APPLICATION_UIDS = 1000;
@@ -740,6 +741,10 @@
                 MULTIPLE_APPLICATION_UIDS
                         ? LOG_UID : FIRST_APPLICATION_UID,
                 ApplicationInfo.FLAG_SYSTEM);
+        mSettings.addSharedUserLP("android.uid.nfc",
+                MULTIPLE_APPLICATION_UIDS
+                        ? NFC_UID : FIRST_APPLICATION_UID,
+                ApplicationInfo.FLAG_SYSTEM);
 
         String separateProcesses = SystemProperties.get("debug.separate_processes");
         if (separateProcesses != null && separateProcesses.length() > 0) {
diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java
index a2a5e67..df69b76 100644
--- a/services/java/com/android/server/SystemServer.java
+++ b/services/java/com/android/server/SystemServer.java
@@ -20,7 +20,6 @@
 import com.android.internal.app.ShutdownThread;
 import com.android.internal.os.BinderInternal;
 import com.android.internal.os.SamplingProfilerIntegration;
-import com.trustedlogic.trustednfc.android.server.NfcService;
 
 import dalvik.system.VMRuntime;
 import dalvik.system.Zygote;
@@ -437,20 +436,6 @@
             }
             
             try {
-                Slog.i(TAG, "Nfc Service");
-                NfcService nfc;
-                try {
-                    nfc = new NfcService(context);
-                } catch (UnsatisfiedLinkError e) { // gross hack to detect NFC
-                    nfc = null;
-                    Slog.w(TAG, "No NFC support");
-                }
-                ServiceManager.addService(Context.NFC_SERVICE, nfc);
-            } catch (Throwable e) {
-                Slog.e(TAG, "Failure starting NFC Service", e);
-            }
-
-            try {
                 Slog.i(TAG, "DiskStats Service");
                 ServiceManager.addService("diskstats", new DiskStatsService(context));
             } catch (Throwable e) {
diff --git a/services/java/com/trustedlogic/trustednfc/android/server/NfcService.java b/services/java/com/trustedlogic/trustednfc/android/server/NfcService.java
deleted file mode 100644
index bddbafc..0000000
--- a/services/java/com/trustedlogic/trustednfc/android/server/NfcService.java
+++ /dev/null
@@ -1,2157 +0,0 @@
-/*
- * Copyright (C) 2010 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.trustedlogic.trustednfc.android.server;
-
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.ListIterator;
-
-import android.nfc.ErrorCodes;
-import android.nfc.FormatException;
-import android.nfc.ILlcpConnectionlessSocket;
-import android.nfc.ILlcpServiceSocket;
-import android.nfc.INfcAdapter;
-import android.nfc.ILlcpSocket;
-import android.nfc.INfcTag;
-import android.nfc.IP2pInitiator;
-import android.nfc.IP2pTarget;
-import android.nfc.LlcpPacket;
-import android.nfc.NdefMessage;
-import android.nfc.Tag;
-//import android.nfc.NfcException;
-//import android.nfc.NfcManager;
-import android.nfc.NfcAdapter;
-import com.trustedlogic.trustednfc.android.internal.NativeLlcpConnectionlessSocket;
-import com.trustedlogic.trustednfc.android.internal.NativeLlcpServiceSocket;
-import com.trustedlogic.trustednfc.android.internal.NativeLlcpSocket;
-import com.trustedlogic.trustednfc.android.internal.NativeNfcManager;
-import com.trustedlogic.trustednfc.android.internal.NativeNfcTag;
-import com.trustedlogic.trustednfc.android.internal.NativeP2pDevice;
-import android.os.Handler;
-import android.os.Looper;
-import android.os.Message;
-import android.os.Process;
-import android.os.RemoteException;
-import android.provider.Settings;
-import android.util.Log;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
-
-public class NfcService extends INfcAdapter.Stub implements Runnable {
-
-    /**
-     * NFC Service tag
-     */
-    private static final String TAG = "NfcService";
-
-    /**
-     * NFC features disabled state
-     */
-    private static final short NFC_STATE_DISABLED = 0x00;
-
-    /**
-     * NFC features enabled state
-     */
-    private static final short NFC_STATE_ENABLED = 0x01;
-
-    /**
-     * NFC Discovery for Reader mode
-     */
-    private static final int DISCOVERY_MODE_READER = 0;
-
-    /**
-     * NFC Discovery for Card Emulation Mode
-     */
-    private static final int DISCOVERY_MODE_CARD_EMULATION = 2;
-
-    /**
-     * LLCP Service Socket type
-     */
-    private static final int LLCP_SERVICE_SOCKET_TYPE = 0;
-
-    /**
-     * LLCP Socket type
-     */
-    private static final int LLCP_SOCKET_TYPE = 1;
-
-    /**
-     * LLCP Connectionless socket type
-     */
-    private static final int LLCP_CONNECTIONLESS_SOCKET_TYPE = 2;
-
-    /**
-     * Maximun number of sockets managed
-     */
-    private static final int LLCP_SOCKET_NB_MAX = 5;
-
-    /**
-     * Default value for the Maximum Information Unit parameter
-     */
-    private static final int LLCP_LTO_DEFAULT_VALUE = 150;
-
-    /**
-     * Default value for the Maximum Information Unit parameter
-     */
-    private static final int LLCP_LTO_MAX_VALUE = 255;
-
-    /**
-     * Maximun value for the Receive Window
-     */
-    private static final int LLCP_RW_MAX_VALUE = 15;
-
-    /**
-     * Default value for the Maximum Information Unit parameter
-     */
-    private static final int LLCP_MIU_DEFAULT_VALUE = 128;
-
-    /**
-     * Default value for the Maximum Information Unit parameter
-     */
-    private static final int LLCP_MIU_MAX_VALUE = 2176;
-
-    /**
-     * Default value for the Well Known Service List parameter
-     */
-    private static final int LLCP_WKS_DEFAULT_VALUE = 1;
-
-    /**
-     * Max value for the Well Known Service List parameter
-     */
-    private static final int LLCP_WKS_MAX_VALUE = 15;
-
-    /**
-     * Default value for the Option parameter
-     */
-    private static final int LLCP_OPT_DEFAULT_VALUE = 0;
-
-    /**
-     * Max value for the Option parameter
-     */
-    private static final int LLCP_OPT_MAX_VALUE = 3;
-
-    /**
-     * LLCP Properties
-     */
-    private static final int PROPERTY_LLCP_LTO = 0;
-
-    private static final int PROPERTY_LLCP_MIU = 1;
-
-    private static final int PROPERTY_LLCP_WKS = 2;
-
-    private static final int PROPERTY_LLCP_OPT = 3;
-
-    private static final String PROPERTY_LLCP_LTO_VALUE = "llcp.lto";
-
-    private static final String PROPERTY_LLCP_MIU_VALUE = "llcp.miu";
-
-    private static final String PROPERTY_LLCP_WKS_VALUE = "llcp.wks";
-
-    private static final String PROPERTY_LLCP_OPT_VALUE = "llcp.opt";
-
-    /**
-     * NFC Reader Properties
-     */
-    private static final int PROPERTY_NFC_DISCOVERY_A = 4;
-
-    private static final int PROPERTY_NFC_DISCOVERY_B = 5;
-
-    private static final int PROPERTY_NFC_DISCOVERY_F = 6;
-
-    private static final int PROPERTY_NFC_DISCOVERY_15693 = 7;
-
-    private static final int PROPERTY_NFC_DISCOVERY_NFCIP = 8;
-
-    private static final String PROPERTY_NFC_DISCOVERY_A_VALUE = "discovery.iso14443A";
-
-    private static final String PROPERTY_NFC_DISCOVERY_B_VALUE = "discovery.iso14443B";
-
-    private static final String PROPERTY_NFC_DISCOVERY_F_VALUE = "discovery.felica";
-
-    private static final String PROPERTY_NFC_DISCOVERY_15693_VALUE = "discovery.iso15693";
-
-    private static final String PROPERTY_NFC_DISCOVERY_NFCIP_VALUE = "discovery.nfcip";
-
-    private final Context mContext;
-
-    private final HashMap<Integer, Object> mObjectMap = new HashMap<Integer, Object>();
-
-    private final HashMap<Integer, Object> mSocketMap = new HashMap<Integer, Object>();
-
-    private final LinkedList<RegisteredSocket> mRegisteredSocketList = new LinkedList<RegisteredSocket>();
-
-    private int mLlcpLinkState = NfcAdapter.LLCP_LINK_STATE_DEACTIVATED;
-
-    private int mGeneratedSocketHandle = 0;
-
-    private int mNbSocketCreated = 0;
-
-    private boolean mIsNfcEnabled = false;
-
-    private NfcHandler mNfcHandler;
-
-    private int mSelectedSeId = 0;
-
-    private int mTimeout = 0;
-
-    private int mNfcState;
-
-    private int mNfcSecureElementState;
-
-    private boolean mOpenPending = false;
-
-    private final NativeNfcManager mManager;
-
-    private final ILlcpSocket mLlcpSocket = new ILlcpSocket.Stub() {
-
-        private final int CONNECT_FLAG = 0x01;
-        private final int CLOSE_FLAG   = 0x02;
-        private final int RECV_FLAG    = 0x04;
-        private final int SEND_FLAG    = 0x08;
-
-        private int concurrencyFlags;
-        private Object sync;
-
-        private void enterCritical(int mask, int current) {
-            int result = -1;
-            try {
-                while (result != 0) {
-                    synchronized(this) {
-                        result = concurrencyFlags & mask;
-                    }
-                    sync.wait();
-                }
-            }
-            catch(InterruptedException e) {
-            }
-            // Set flag
-            concurrencyFlags |= current;
-        }
-
-        private void leaveCritical(int current) {
-            synchronized(this) {
-                // Clear flag
-                concurrencyFlags &= ~current;
-            }
-            // Release waiting threads
-            sync.notifyAll();
-        }
-
-        public int close(int nativeHandle) throws RemoteException {
-            NativeLlcpSocket socket = null;
-            boolean isSuccess = false;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                if (mLlcpLinkState == NfcAdapter.LLCP_LINK_STATE_ACTIVATED) {
-                    isSuccess = socket.doClose();
-                    if (isSuccess) {
-                        /* Remove the socket closed from the hmap */
-                        RemoveSocket(nativeHandle);
-                        /* Update mNbSocketCreated */
-                        mNbSocketCreated--;
-                        return ErrorCodes.SUCCESS;
-                    } else {
-                        return ErrorCodes.ERROR_IO;
-                    }
-                } else {
-                    /* Remove the socket closed from the hmap */
-                    RemoveSocket(nativeHandle);
-
-                    /* Remove registered socket from the list */
-                    RemoveRegisteredSocket(nativeHandle);
-
-                    /* Update mNbSocketCreated */
-                    mNbSocketCreated--;
-
-                    return ErrorCodes.SUCCESS;
-                }
-            } else {
-                return ErrorCodes.ERROR_IO;
-            }
-        }
-
-        public int connect(int nativeHandle, int sap) throws RemoteException {
-            NativeLlcpSocket socket = null;
-            boolean isSuccess = false;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                isSuccess = socket.doConnect(sap, socket.getConnectTimeout());
-                if (isSuccess) {
-                    return ErrorCodes.SUCCESS;
-                } else {
-                    return ErrorCodes.ERROR_IO;
-                }
-            } else {
-                return ErrorCodes.ERROR_IO;
-            }
-
-        }
-
-        public int connectByName(int nativeHandle, String sn) throws RemoteException {
-            NativeLlcpSocket socket = null;
-            boolean isSuccess = false;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                isSuccess = socket.doConnectBy(sn, socket.getConnectTimeout());
-                if (isSuccess) {
-                    return ErrorCodes.SUCCESS;
-                } else {
-                    return ErrorCodes.ERROR_IO;
-                }
-            } else {
-                return ErrorCodes.ERROR_IO;
-            }
-
-        }
-
-        public int getConnectTimeout(int nativeHandle) throws RemoteException {
-            NativeLlcpSocket socket = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                return socket.getConnectTimeout();
-            } else {
-                return 0;
-            }
-        }
-
-        public int getLocalSap(int nativeHandle) throws RemoteException {
-            NativeLlcpSocket socket = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                return socket.getSap();
-            } else {
-                return 0;
-            }
-        }
-
-        public int getLocalSocketMiu(int nativeHandle) throws RemoteException {
-            NativeLlcpSocket socket = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                return socket.getMiu();
-            } else {
-                return 0;
-            }
-        }
-
-        public int getLocalSocketRw(int nativeHandle) throws RemoteException {
-            NativeLlcpSocket socket = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                return socket.getRw();
-            } else {
-                return 0;
-            }
-        }
-
-        public int getRemoteSocketMiu(int nativeHandle) throws RemoteException {
-            NativeLlcpSocket socket = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                if (socket.doGetRemoteSocketMiu() != 0) {
-                    return socket.doGetRemoteSocketMiu();
-                } else {
-                    return ErrorCodes.ERROR_SOCKET_NOT_CONNECTED;
-                }
-            } else {
-                return ErrorCodes.ERROR_SOCKET_NOT_CONNECTED;
-            }
-        }
-
-        public int getRemoteSocketRw(int nativeHandle) throws RemoteException {
-            NativeLlcpSocket socket = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                if (socket.doGetRemoteSocketRw() != 0) {
-                    return socket.doGetRemoteSocketRw();
-                } else {
-                    return ErrorCodes.ERROR_SOCKET_NOT_CONNECTED;
-                }
-            } else {
-                return ErrorCodes.ERROR_SOCKET_NOT_CONNECTED;
-            }
-        }
-
-        public int receive(int nativeHandle, byte[] receiveBuffer) throws RemoteException {
-            NativeLlcpSocket socket = null;
-            int receiveLength = 0;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                receiveLength = socket.doReceive(receiveBuffer);
-                if (receiveLength != 0) {
-                    return receiveLength;
-                } else {
-                    return ErrorCodes.ERROR_IO;
-                }
-            } else {
-                return ErrorCodes.ERROR_IO;
-            }
-        }
-
-        public int send(int nativeHandle, byte[] data) throws RemoteException {
-            NativeLlcpSocket socket = null;
-            boolean isSuccess = false;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                isSuccess = socket.doSend(data);
-                if (isSuccess) {
-                    return ErrorCodes.SUCCESS;
-                } else {
-                    return ErrorCodes.ERROR_IO;
-                }
-            } else {
-                return ErrorCodes.ERROR_IO;
-            }
-        }
-
-        public void setConnectTimeout(int nativeHandle, int timeout) throws RemoteException {
-            NativeLlcpSocket socket = null;
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                socket.setConnectTimeout(timeout);
-            }
-        }
-
-    };
-
-    private final ILlcpServiceSocket mLlcpServerSocketService = new ILlcpServiceSocket.Stub() {
-
-        public int accept(int nativeHandle) throws RemoteException {
-            NativeLlcpServiceSocket socket = null;
-            NativeLlcpSocket clientSocket = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            if (mNbSocketCreated < LLCP_SOCKET_NB_MAX) {
-                /* find the socket in the hmap */
-                socket = (NativeLlcpServiceSocket) findSocket(nativeHandle);
-                if (socket != null) {
-                    clientSocket = socket.doAccept(socket.getAcceptTimeout(), socket.getMiu(),
-                            socket.getRw(), socket.getLinearBufferLength());
-                    if (clientSocket != null) {
-                        /* Add the socket into the socket map */
-                        mSocketMap.put(clientSocket.getHandle(), clientSocket);
-                        mNbSocketCreated++;
-                        return clientSocket.getHandle();
-                    } else {
-                        return ErrorCodes.ERROR_IO;
-                    }
-                } else {
-                    return ErrorCodes.ERROR_IO;
-                }
-            } else {
-                return ErrorCodes.ERROR_INSUFFICIENT_RESOURCES;
-            }
-
-        }
-
-        public void close(int nativeHandle) throws RemoteException {
-            NativeLlcpServiceSocket socket = null;
-            boolean isSuccess = false;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpServiceSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                if (mLlcpLinkState == NfcAdapter.LLCP_LINK_STATE_ACTIVATED) {
-                    isSuccess = socket.doClose();
-                    if (isSuccess) {
-                        /* Remove the socket closed from the hmap */
-                        RemoveSocket(nativeHandle);
-                        /* Update mNbSocketCreated */
-                        mNbSocketCreated--;
-                    }
-                } else {
-                    /* Remove the socket closed from the hmap */
-                    RemoveSocket(nativeHandle);
-
-                    /* Remove registered socket from the list */
-                    RemoveRegisteredSocket(nativeHandle);
-
-                    /* Update mNbSocketCreated */
-                    mNbSocketCreated--;
-                }
-            }
-        }
-
-        public int getAcceptTimeout(int nativeHandle) throws RemoteException {
-            NativeLlcpServiceSocket socket = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpServiceSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                return socket.getAcceptTimeout();
-            } else {
-                return 0;
-            }
-        }
-
-        public void setAcceptTimeout(int nativeHandle, int timeout) throws RemoteException {
-            NativeLlcpServiceSocket socket = null;
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpServiceSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                socket.setAcceptTimeout(timeout);
-            }
-        }
-    };
-
-    private final ILlcpConnectionlessSocket mLlcpConnectionlessSocketService = new ILlcpConnectionlessSocket.Stub() {
-
-        public void close(int nativeHandle) throws RemoteException {
-            NativeLlcpConnectionlessSocket socket = null;
-            boolean isSuccess = false;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpConnectionlessSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                if (mLlcpLinkState == NfcAdapter.LLCP_LINK_STATE_ACTIVATED) {
-                    isSuccess = socket.doClose();
-                    if (isSuccess) {
-                        /* Remove the socket closed from the hmap */
-                        RemoveSocket(nativeHandle);
-                        /* Update mNbSocketCreated */
-                        mNbSocketCreated--;
-                    }
-                } else {
-                    /* Remove the socket closed from the hmap */
-                    RemoveSocket(nativeHandle);
-
-                    /* Remove registered socket from the list */
-                    RemoveRegisteredSocket(nativeHandle);
-
-                    /* Update mNbSocketCreated */
-                    mNbSocketCreated--;
-                }
-            }
-        }
-
-        public int getSap(int nativeHandle) throws RemoteException {
-            NativeLlcpConnectionlessSocket socket = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpConnectionlessSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                return socket.getSap();
-            } else {
-                return 0;
-            }
-        }
-
-        public LlcpPacket receiveFrom(int nativeHandle) throws RemoteException {
-            NativeLlcpConnectionlessSocket socket = null;
-            LlcpPacket packet;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return null;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpConnectionlessSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                packet = socket.doReceiveFrom(socket.getLinkMiu());
-                if (packet != null) {
-                    return packet;
-                }
-                return null;
-            } else {
-                return null;
-            }
-        }
-
-        public int sendTo(int nativeHandle, LlcpPacket packet) throws RemoteException {
-            NativeLlcpConnectionlessSocket socket = null;
-            boolean isSuccess = false;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the socket in the hmap */
-            socket = (NativeLlcpConnectionlessSocket) findSocket(nativeHandle);
-            if (socket != null) {
-                isSuccess = socket.doSendTo(packet.getRemoteSap(), packet.getDataBuffer());
-                if (isSuccess) {
-                    return ErrorCodes.SUCCESS;
-                } else {
-                    return ErrorCodes.ERROR_IO;
-                }
-            } else {
-                return ErrorCodes.ERROR_IO;
-            }
-        }
-    };
-
-    private final INfcTag mNfcTagService = new INfcTag.Stub() {
-
-        public int close(int nativeHandle) throws RemoteException {
-            NativeNfcTag tag = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the tag in the hmap */
-            tag = (NativeNfcTag) findObject(nativeHandle);
-            if (tag != null) {
-                if (tag.doDisconnect()) {
-                    /* Remove the device from the hmap */
-                    RemoveObject(nativeHandle);
-                    /* Restart polling loop for notification */
-                    mManager.enableDiscovery(DISCOVERY_MODE_READER);
-                    mOpenPending = false;
-                    return ErrorCodes.SUCCESS;
-                }
-
-            }
-            /* Restart polling loop for notification */
-            mManager.enableDiscovery(DISCOVERY_MODE_READER);
-            mOpenPending = false;
-            return ErrorCodes.ERROR_DISCONNECT;
-        }
-
-        public int connect(int nativeHandle) throws RemoteException {
-            NativeNfcTag tag = null;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the tag in the hmap */
-            tag = (NativeNfcTag) findObject(nativeHandle);
-            if (tag != null) {
-                if (tag.doConnect())
-                    return ErrorCodes.SUCCESS;
-            }
-            /* Restart polling loop for notification */
-            mManager.enableDiscovery(DISCOVERY_MODE_READER);
-            mOpenPending = false;
-            return ErrorCodes.ERROR_CONNECT;
-        }
-
-        public String getType(int nativeHandle) throws RemoteException {
-            NativeNfcTag tag = null;
-            String type;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return null;
-            }
-
-            /* find the tag in the hmap */
-            tag = (NativeNfcTag) findObject(nativeHandle);
-            if (tag != null) {
-                type = tag.getType();
-                return type;
-            }
-            return null;
-        }
-
-        public byte[] getUid(int nativeHandle) throws RemoteException {
-            NativeNfcTag tag = null;
-            byte[] uid;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return null;
-            }
-
-            /* find the tag in the hmap */
-            tag = (NativeNfcTag) findObject(nativeHandle);
-            if (tag != null) {
-                uid = tag.getUid();
-                return uid;
-            }
-            return null;
-        }
-
-        public boolean isNdef(int nativeHandle) throws RemoteException {
-            NativeNfcTag tag = null;
-            boolean isSuccess = false;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return isSuccess;
-            }
-
-            /* find the tag in the hmap */
-            tag = (NativeNfcTag) findObject(nativeHandle);
-            if (tag != null) {
-                isSuccess = tag.checkNDEF();
-            }
-            return isSuccess;
-        }
-
-        public byte[] transceive(int nativeHandle, byte[] data) throws RemoteException {
-            NativeNfcTag tag = null;
-            byte[] response;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return null;
-            }
-
-            /* find the tag in the hmap */
-            tag = (NativeNfcTag) findObject(nativeHandle);
-            if (tag != null) {
-                response = tag.doTransceive(data);
-                return response;
-            }
-            return null;
-        }
-
-        public NdefMessage read(int nativeHandle) throws RemoteException {
-            NativeNfcTag tag;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return null;
-            }
-
-            /* find the tag in the hmap */
-            tag = (NativeNfcTag) findObject(nativeHandle);
-            if (tag != null) {
-                byte[] buf = tag.doRead();
-                if (buf == null)
-                    return null;
-
-                /* Create an NdefMessage */
-                try {
-                    return new NdefMessage(buf);
-                } catch (FormatException e) {
-                    return null;
-                }
-            }
-            return null;
-        }
-
-        public int write(int nativeHandle, NdefMessage msg) throws RemoteException {
-            NativeNfcTag tag;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the tag in the hmap */
-            tag = (NativeNfcTag) findObject(nativeHandle);
-            if (tag == null) {
-                return ErrorCodes.ERROR_IO;
-            }
-
-            if (tag.doWrite(msg.toByteArray())) {
-                return ErrorCodes.SUCCESS;
-            }
-            else {
-                return ErrorCodes.ERROR_IO;
-            }
-
-        }
-
-        public int getLastError(int nativeHandle) throws RemoteException {
-            // TODO Auto-generated method stub
-            return 0;
-        }
-
-        public int getModeHint(int nativeHandle) throws RemoteException {
-            // TODO Auto-generated method stub
-            return 0;
-        }
-
-        public int makeReadOnly(int nativeHandle) throws RemoteException {
-            // TODO Auto-generated method stub
-            return 0;
-        }
-
-
-    };
-
-    private final IP2pInitiator mP2pInitiatorService = new IP2pInitiator.Stub() {
-
-        public byte[] getGeneralBytes(int nativeHandle) throws RemoteException {
-            NativeP2pDevice device;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return null;
-            }
-
-            /* find the device in the hmap */
-            device = (NativeP2pDevice) findObject(nativeHandle);
-            if (device != null) {
-                byte[] buff = device.getGeneralBytes();
-                if (buff == null)
-                    return null;
-                return buff;
-            }
-            return null;
-        }
-
-        public int getMode(int nativeHandle) throws RemoteException {
-            NativeP2pDevice device;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the device in the hmap */
-            device = (NativeP2pDevice) findObject(nativeHandle);
-            if (device != null) {
-                return device.getMode();
-            }
-            return ErrorCodes.ERROR_INVALID_PARAM;
-        }
-
-        public byte[] receive(int nativeHandle) throws RemoteException {
-            NativeP2pDevice device;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return null;
-            }
-
-            /* find the device in the hmap */
-            device = (NativeP2pDevice) findObject(nativeHandle);
-            if (device != null) {
-                byte[] buff = device.doReceive();
-                if (buff == null)
-                    return null;
-                return buff;
-            }
-            /* Restart polling loop for notification */
-            mManager.enableDiscovery(DISCOVERY_MODE_READER);
-            mOpenPending = false;
-            return null;
-        }
-
-        public boolean send(int nativeHandle, byte[] data) throws RemoteException {
-            NativeP2pDevice device;
-            boolean isSuccess = false;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return isSuccess;
-            }
-
-            /* find the device in the hmap */
-            device = (NativeP2pDevice) findObject(nativeHandle);
-            if (device != null) {
-                isSuccess = device.doSend(data);
-            }
-            return isSuccess;
-        }
-    };
-
-    private final IP2pTarget mP2pTargetService = new IP2pTarget.Stub() {
-
-        public int connect(int nativeHandle) throws RemoteException {
-            NativeP2pDevice device;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the device in the hmap */
-            device = (NativeP2pDevice) findObject(nativeHandle);
-            if (device != null) {
-                if (device.doConnect()) {
-                    return ErrorCodes.SUCCESS;
-                }
-            }
-            return ErrorCodes.ERROR_CONNECT;
-        }
-
-        public boolean disconnect(int nativeHandle) throws RemoteException {
-            NativeP2pDevice device;
-            boolean isSuccess = false;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return isSuccess;
-            }
-
-            /* find the device in the hmap */
-            device = (NativeP2pDevice) findObject(nativeHandle);
-            if (device != null) {
-                if (isSuccess = device.doDisconnect()) {
-                    mOpenPending = false;
-                    /* remove the device from the hmap */
-                    RemoveObject(nativeHandle);
-                    /* Restart polling loop for notification */
-                    mManager.enableDiscovery(DISCOVERY_MODE_READER);
-                }
-            }
-            return isSuccess;
-
-        }
-
-        public byte[] getGeneralBytes(int nativeHandle) throws RemoteException {
-            NativeP2pDevice device;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return null;
-            }
-
-            /* find the device in the hmap */
-            device = (NativeP2pDevice) findObject(nativeHandle);
-            if (device != null) {
-                byte[] buff = device.getGeneralBytes();
-                if (buff == null)
-                    return null;
-                return buff;
-            }
-            return null;
-        }
-
-        public int getMode(int nativeHandle) throws RemoteException {
-            NativeP2pDevice device;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return ErrorCodes.ERROR_NOT_INITIALIZED;
-            }
-
-            /* find the device in the hmap */
-            device = (NativeP2pDevice) findObject(nativeHandle);
-            if (device != null) {
-                return device.getMode();
-            }
-            return ErrorCodes.ERROR_INVALID_PARAM;
-        }
-
-        public byte[] transceive(int nativeHandle, byte[] data) throws RemoteException {
-            NativeP2pDevice device;
-
-            // Check if NFC is enabled
-            if (!mIsNfcEnabled) {
-                return null;
-            }
-
-            /* find the device in the hmap */
-            device = (NativeP2pDevice) findObject(nativeHandle);
-            if (device != null) {
-                byte[] buff = device.doTransceive(data);
-                if (buff == null)
-                    return null;
-                return buff;
-            }
-            return null;
-        }
-    };
-
-    private class NfcHandler extends Handler {
-
-        @Override
-        public void handleMessage(Message msg) {
-            try {
-
-            } catch (Exception e) {
-                // Log, don't crash!
-                Log.e(TAG, "Exception in NfcHandler.handleMessage:", e);
-            }
-        }
-
-    };
-
-    public NfcService(Context context) {
-        super();
-        mContext = context;
-        mManager = new NativeNfcManager(mContext);
-
-        mContext.registerReceiver(mNfcServiceReceiver, new IntentFilter(
-                NativeNfcManager.INTERNAL_LLCP_LINK_STATE_CHANGED_ACTION));
-
-        mContext.registerReceiver(mNfcServiceReceiver, new IntentFilter(
-                NfcAdapter.ACTION_LLCP_LINK_STATE_CHANGED));
-
-        mContext.registerReceiver(mNfcServiceReceiver, new IntentFilter(
-                NativeNfcManager.INTERNAL_TARGET_DESELECTED_ACTION));
-
-        Thread thread = new Thread(null, this, "NfcService");
-        thread.start();
-
-        mManager.initializeNativeStructure();
-
-            int nfcState = Settings.System.getInt(mContext.getContentResolver(),
-                Settings.System.NFC_ON, 0);
-
-            if (nfcState == NFC_STATE_ENABLED) {
-                if (this._enable()) {
-                }
-            }
-
-    }
-
-    public void run() {
-        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
-        Looper.prepare();
-        mNfcHandler = new NfcHandler();
-        Looper.loop();
-    }
-
-    public void cancel() throws RemoteException {
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_RAW,
-                "NFC_RAW permission required to cancel NFC opening");
-        if (mOpenPending) {
-            mOpenPending = false;
-            mManager.doCancel();
-            /* Restart polling loop for notification */
-            mManager.enableDiscovery(DISCOVERY_MODE_READER);
-        }
-    }
-
-    public int createLlcpConnectionlessSocket(int sap) throws RemoteException {
-
-        // Check if NFC is enabled
-        if (!mIsNfcEnabled) {
-            return ErrorCodes.ERROR_NOT_INITIALIZED;
-        }
-
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_LLCP,
-                "NFC_LLCP permission required for LLCP operations with NFC service");
-
-        /* Check SAP is not already used */
-
-        /* Check nb socket created */
-        if (mNbSocketCreated < LLCP_SOCKET_NB_MAX) {
-            /* Store the socket handle */
-            int sockeHandle = mGeneratedSocketHandle;
-
-            if (mLlcpLinkState == NfcAdapter.LLCP_LINK_STATE_ACTIVATED) {
-                NativeLlcpConnectionlessSocket socket;
-
-                socket = mManager.doCreateLlcpConnectionlessSocket(sap);
-                if (socket != null) {
-                    /* Update the number of socket created */
-                    mNbSocketCreated++;
-
-                    /* Add the socket into the socket map */
-                    mSocketMap.put(sockeHandle, socket);
-
-                    return sockeHandle;
-                } else {
-                    /*
-                     * socket creation error - update the socket handle
-                     * generation
-                     */
-                    mGeneratedSocketHandle -= 1;
-
-                    /* Get Error Status */
-                    int errorStatus = mManager.doGetLastError();
-
-                    switch (errorStatus) {
-                        case ErrorCodes.ERROR_BUFFER_TO_SMALL:
-                            return ErrorCodes.ERROR_BUFFER_TO_SMALL;
-                        case ErrorCodes.ERROR_INSUFFICIENT_RESOURCES:
-                            return ErrorCodes.ERROR_INSUFFICIENT_RESOURCES;
-                        default:
-                            return ErrorCodes.ERROR_SOCKET_CREATION;
-                    }
-                }
-            } else {
-                /* Check SAP is not already used */
-                if (!CheckSocketSap(sap)) {
-                    return ErrorCodes.ERROR_SAP_USED;
-                }
-
-                NativeLlcpConnectionlessSocket socket = new NativeLlcpConnectionlessSocket(sap);
-
-                /* Add the socket into the socket map */
-                mSocketMap.put(sockeHandle, socket);
-
-                /* Update the number of socket created */
-                mNbSocketCreated++;
-
-                /* Create new registered socket */
-                RegisteredSocket registeredSocket = new RegisteredSocket(
-                        LLCP_CONNECTIONLESS_SOCKET_TYPE, sockeHandle, sap);
-
-                /* Put this socket into a list of registered socket */
-                mRegisteredSocketList.add(registeredSocket);
-            }
-
-            /* update socket handle generation */
-            mGeneratedSocketHandle++;
-
-            return sockeHandle;
-
-        } else {
-            /* No socket available */
-            return ErrorCodes.ERROR_INSUFFICIENT_RESOURCES;
-        }
-
-    }
-
-    public int createLlcpServiceSocket(int sap, String sn, int miu, int rw, int linearBufferLength)
-            throws RemoteException {
-
-        // Check if NFC is enabled
-        if (!mIsNfcEnabled) {
-            return ErrorCodes.ERROR_NOT_INITIALIZED;
-        }
-
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_LLCP,
-                "NFC_LLCP permission required for LLCP operations with NFC service");
-
-        if (mNbSocketCreated < LLCP_SOCKET_NB_MAX) {
-            int sockeHandle = mGeneratedSocketHandle;
-
-            if (mLlcpLinkState == NfcAdapter.LLCP_LINK_STATE_ACTIVATED) {
-                NativeLlcpServiceSocket socket;
-
-                socket = mManager.doCreateLlcpServiceSocket(sap, sn, miu, rw, linearBufferLength);
-                if (socket != null) {
-                    /* Update the number of socket created */
-                    mNbSocketCreated++;
-                    /* Add the socket into the socket map */
-                    mSocketMap.put(sockeHandle, socket);
-                } else {
-                    /* socket creation error - update the socket handle counter */
-                    mGeneratedSocketHandle -= 1;
-
-                    /* Get Error Status */
-                    int errorStatus = mManager.doGetLastError();
-
-                    switch (errorStatus) {
-                        case ErrorCodes.ERROR_BUFFER_TO_SMALL:
-                            return ErrorCodes.ERROR_BUFFER_TO_SMALL;
-                        case ErrorCodes.ERROR_INSUFFICIENT_RESOURCES:
-                            return ErrorCodes.ERROR_INSUFFICIENT_RESOURCES;
-                        default:
-                            return ErrorCodes.ERROR_SOCKET_CREATION;
-                    }
-                }
-            } else {
-
-                /* Check SAP is not already used */
-                if (!CheckSocketSap(sap)) {
-                    return ErrorCodes.ERROR_SAP_USED;
-                }
-
-                /* Service Name */
-                if (!CheckSocketServiceName(sn)) {
-                    return ErrorCodes.ERROR_SERVICE_NAME_USED;
-                }
-
-                /* Check socket options */
-                if (!CheckSocketOptions(miu, rw, linearBufferLength)) {
-                    return ErrorCodes.ERROR_SOCKET_OPTIONS;
-                }
-
-                NativeLlcpServiceSocket socket = new NativeLlcpServiceSocket(sn);
-
-                /* Add the socket into the socket map */
-                mSocketMap.put(sockeHandle, socket);
-
-                /* Update the number of socket created */
-                mNbSocketCreated++;
-
-                /* Create new registered socket */
-                RegisteredSocket registeredSocket = new RegisteredSocket(LLCP_SERVICE_SOCKET_TYPE,
-                        sockeHandle, sap, sn, miu, rw, linearBufferLength);
-
-                /* Put this socket into a list of registered socket */
-                mRegisteredSocketList.add(registeredSocket);
-            }
-
-            /* update socket handle generation */
-            mGeneratedSocketHandle += 1;
-
-            Log.d(TAG, "Llcp Service Socket Handle =" + sockeHandle);
-            return sockeHandle;
-        } else {
-            /* No socket available */
-            return ErrorCodes.ERROR_INSUFFICIENT_RESOURCES;
-        }
-    }
-
-    public int createLlcpSocket(int sap, int miu, int rw, int linearBufferLength)
-            throws RemoteException {
-
-        // Check if NFC is enabled
-        if (!mIsNfcEnabled) {
-            return ErrorCodes.ERROR_NOT_INITIALIZED;
-        }
-
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_LLCP,
-                "NFC_LLCP permission required for LLCP operations with NFC service");
-
-        if (mNbSocketCreated < LLCP_SOCKET_NB_MAX) {
-
-            int sockeHandle = mGeneratedSocketHandle;
-
-            if (mLlcpLinkState == NfcAdapter.LLCP_LINK_STATE_ACTIVATED) {
-                NativeLlcpSocket socket;
-
-                socket = mManager.doCreateLlcpSocket(sap, miu, rw, linearBufferLength);
-
-                if (socket != null) {
-                    /* Update the number of socket created */
-                    mNbSocketCreated++;
-                    /* Add the socket into the socket map */
-                    mSocketMap.put(sockeHandle, socket);
-                } else {
-                    /*
-                     * socket creation error - update the socket handle
-                     * generation
-                     */
-                    mGeneratedSocketHandle -= 1;
-
-                    /* Get Error Status */
-                    int errorStatus = mManager.doGetLastError();
-
-                    switch (errorStatus) {
-                        case ErrorCodes.ERROR_BUFFER_TO_SMALL:
-                            return ErrorCodes.ERROR_BUFFER_TO_SMALL;
-                        case ErrorCodes.ERROR_INSUFFICIENT_RESOURCES:
-                            return ErrorCodes.ERROR_INSUFFICIENT_RESOURCES;
-                        default:
-                            return ErrorCodes.ERROR_SOCKET_CREATION;
-                    }
-                }
-            } else {
-
-                /* Check SAP is not already used */
-                if (!CheckSocketSap(sap)) {
-                    return ErrorCodes.ERROR_SAP_USED;
-                }
-
-                /* Check Socket options */
-                if (!CheckSocketOptions(miu, rw, linearBufferLength)) {
-                    return ErrorCodes.ERROR_SOCKET_OPTIONS;
-                }
-
-                NativeLlcpSocket socket = new NativeLlcpSocket(sap, miu, rw);
-
-                /* Add the socket into the socket map */
-                mSocketMap.put(sockeHandle, socket);
-
-                /* Update the number of socket created */
-                mNbSocketCreated++;
-                /* Create new registered socket */
-                RegisteredSocket registeredSocket = new RegisteredSocket(LLCP_SOCKET_TYPE,
-                        sockeHandle, sap, miu, rw, linearBufferLength);
-
-                /* Put this socket into a list of registered socket */
-                mRegisteredSocketList.add(registeredSocket);
-            }
-
-            /* update socket handle generation */
-            mGeneratedSocketHandle++;
-
-            return sockeHandle;
-        } else {
-            /* No socket available */
-            return ErrorCodes.ERROR_INSUFFICIENT_RESOURCES;
-        }
-    }
-
-    public int deselectSecureElement() throws RemoteException {
-        // Check if NFC is enabled
-        if (!mIsNfcEnabled) {
-            return ErrorCodes.ERROR_NOT_INITIALIZED;
-        }
-
-        if (mSelectedSeId == 0) {
-            return ErrorCodes.ERROR_NO_SE_CONNECTED;
-        }
-
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_ADMIN,
-                "NFC_ADMIN permission required to deselect NFC Secure Element");
-
-            mManager.doDeselectSecureElement(mSelectedSeId);
-        mNfcSecureElementState = 0;
-            mSelectedSeId = 0;
-
-        /* Store that a secure element is deselected */
-        Settings.System.putInt(mContext.getContentResolver(),
-                Settings.System.NFC_SECURE_ELEMENT_ON, 0);
-
-        /* Reset Secure Element ID */
-        Settings.System.putInt(mContext.getContentResolver(),
-                Settings.System.NFC_SECURE_ELEMENT_ID, 0);
-
-
-        return ErrorCodes.SUCCESS;
-    }
-
-    public boolean disable() throws RemoteException {
-        boolean isSuccess = false;
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_ADMIN,
-                "NFC_ADMIN permission required to disable NFC service");
-        if (isEnabled()) {
-            isSuccess = mManager.deinitialize();
-            if (isSuccess) {
-                mIsNfcEnabled = false;
-            }
-        }
-
-        updateNfcOnSetting();
-
-        return isSuccess;
-    }
-
-    public boolean enable() throws RemoteException {
-        boolean isSuccess = false;
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_ADMIN,
-                "NFC_ADMIN permission required to enable NFC service");
-        if (!isEnabled()) {
-            reset();
-            isSuccess = _enable();
-        }
-        return isSuccess;
-    }
-
-    private boolean _enable() {
-        boolean isSuccess = mManager.initialize();
-        if (isSuccess) {
-            /* Check persistent properties */
-            checkProperties();
-
-            /* Check Secure Element setting */
-            mNfcSecureElementState = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.NFC_SECURE_ELEMENT_ON, 0);
-
-            if (mNfcSecureElementState == 1) {
-
-                int secureElementId = Settings.System.getInt(mContext.getContentResolver(),
-                        Settings.System.NFC_SECURE_ELEMENT_ID, 0);
-                int[] Se_list = mManager.doGetSecureElementList();
-                if (Se_list != null) {
-                    for (int i = 0; i < Se_list.length; i++) {
-                        if (Se_list[i] == secureElementId) {
-                            mManager.doSelectSecureElement(Se_list[i]);
-                            mSelectedSeId = Se_list[i];
-                            break;
-                        }
-                    }
-                }
-            }
-
-            /* Start polling loop */
-            mManager.enableDiscovery(DISCOVERY_MODE_READER);
-
-            mIsNfcEnabled = true;
-        } else {
-            mIsNfcEnabled = false;
-        }
-
-        updateNfcOnSetting();
-
-        return isSuccess;
-    }
-
-    private void updateNfcOnSetting() {
-        int state;
-
-        if (mIsNfcEnabled) {
-            state = NFC_STATE_ENABLED;
-        } else {
-            state = NFC_STATE_DISABLED;
-        }
-
-        Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_ON, state);
-    }
-
-    private void checkProperties() {
-        int value;
-
-        /* LLCP LTO */
-        value = Settings.System.getInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_LTO,
-                LLCP_LTO_DEFAULT_VALUE);
-        Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_LTO, value);
-        mManager.doSetProperties(PROPERTY_LLCP_LTO, value);
-
-        /* LLCP MIU */
-        value = Settings.System.getInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_MIU,
-                LLCP_MIU_DEFAULT_VALUE);
-        Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_MIU, value);
-        mManager.doSetProperties(PROPERTY_LLCP_MIU, value);
-
-        /* LLCP WKS */
-        value = Settings.System.getInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_WKS,
-                LLCP_WKS_DEFAULT_VALUE);
-        Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_WKS, value);
-        mManager.doSetProperties(PROPERTY_LLCP_WKS, value);
-
-        /* LLCP OPT */
-        value = Settings.System.getInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_OPT,
-                LLCP_OPT_DEFAULT_VALUE);
-        Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_OPT, value);
-        mManager.doSetProperties(PROPERTY_LLCP_OPT, value);
-
-        /* NFC READER A */
-        value = Settings.System.getInt(mContext.getContentResolver(),
-                Settings.System.NFC_DISCOVERY_A, 1);
-        Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_DISCOVERY_A,
-                value);
-        mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_A, value);
-
-        /* NFC READER B */
-        value = Settings.System.getInt(mContext.getContentResolver(),
-                Settings.System.NFC_DISCOVERY_B, 1);
-        Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_DISCOVERY_B,
-                value);
-        mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_B, value);
-
-        /* NFC READER F */
-        value = Settings.System.getInt(mContext.getContentResolver(),
-                Settings.System.NFC_DISCOVERY_F, 1);
-        Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_DISCOVERY_F,
-                value);
-        mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_F, value);
-
-        /* NFC READER 15693 */
-        value = Settings.System.getInt(mContext.getContentResolver(),
-                Settings.System.NFC_DISCOVERY_15693, 1);
-        Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_DISCOVERY_15693,
-                value);
-        mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_15693, value);
-
-        /* NFC NFCIP */
-        value = Settings.System.getInt(mContext.getContentResolver(),
-                Settings.System.NFC_DISCOVERY_NFCIP, 1);
-        Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_DISCOVERY_NFCIP,
-                value);
-        mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_NFCIP, value);
-    }
-
-    public ILlcpConnectionlessSocket getLlcpConnectionlessInterface() throws RemoteException {
-        return mLlcpConnectionlessSocketService;
-    }
-
-    public ILlcpSocket getLlcpInterface() throws RemoteException {
-        return mLlcpSocket;
-    }
-
-    public ILlcpServiceSocket getLlcpServiceInterface() throws RemoteException {
-        return mLlcpServerSocketService;
-    }
-
-    public INfcTag getNfcTagInterface() throws RemoteException {
-        return mNfcTagService;
-    }
-
-    public int getOpenTimeout() throws RemoteException {
-        return mTimeout;
-    }
-
-    public IP2pInitiator getP2pInitiatorInterface() throws RemoteException {
-        return mP2pInitiatorService;
-    }
-
-    public IP2pTarget getP2pTargetInterface() throws RemoteException {
-        return mP2pTargetService;
-    }
-
-    public String getProperties(String param) throws RemoteException {
-        int value;
-
-        if (param == null) {
-            return "Wrong parameter";
-        }
-
-        if (param.equals(PROPERTY_LLCP_LTO_VALUE)) {
-            value = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.NFC_LLCP_LTO, 0);
-        } else if (param.equals(PROPERTY_LLCP_MIU_VALUE)) {
-            value = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.NFC_LLCP_MIU, 0);
-        } else if (param.equals(PROPERTY_LLCP_WKS_VALUE)) {
-            value = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.NFC_LLCP_WKS, 0);
-        } else if (param.equals(PROPERTY_LLCP_OPT_VALUE)) {
-            value = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.NFC_LLCP_OPT, 0);
-        } else if (param.equals(PROPERTY_NFC_DISCOVERY_A_VALUE)) {
-            value = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.NFC_DISCOVERY_A, 0);
-        } else if (param.equals(PROPERTY_NFC_DISCOVERY_B_VALUE)) {
-            value = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.NFC_DISCOVERY_B, 0);
-        } else if (param.equals(PROPERTY_NFC_DISCOVERY_F_VALUE)) {
-            value = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.NFC_DISCOVERY_F, 0);
-        } else if (param.equals(PROPERTY_NFC_DISCOVERY_NFCIP_VALUE)) {
-            value = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.NFC_DISCOVERY_NFCIP, 0);
-        } else if (param.equals(PROPERTY_NFC_DISCOVERY_15693_VALUE)) {
-            value = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.NFC_DISCOVERY_15693, 0);
-        } else {
-            return "Unknown property";
-        }
-
-        if (param.equals(PROPERTY_NFC_DISCOVERY_A_VALUE)
-                || param.equals(PROPERTY_NFC_DISCOVERY_B_VALUE)
-                || param.equals(PROPERTY_NFC_DISCOVERY_F_VALUE)
-                || param.equals(PROPERTY_NFC_DISCOVERY_NFCIP_VALUE)
-                || param.equals(PROPERTY_NFC_DISCOVERY_15693_VALUE)) {
-            if (value == 0) {
-                return "false";
-            } else if (value == 1) {
-                return "true";
-            } else {
-                return "Unknown Value";
-            }
-        }else{
-            return "" + value;
-        }
-
-    }
-
-    public int[] getSecureElementList() throws RemoteException {
-        int[] list = null;
-        if (mIsNfcEnabled == true) {
-            list = mManager.doGetSecureElementList();
-        }
-        return list;
-    }
-
-    public int getSelectedSecureElement() throws RemoteException {
-        return mSelectedSeId;
-    }
-
-    public boolean isEnabled() throws RemoteException {
-        return mIsNfcEnabled;
-    }
-
-    public int openP2pConnection() throws RemoteException {
-        // Check if NFC is enabled
-        if (!mIsNfcEnabled) {
-            return ErrorCodes.ERROR_NOT_INITIALIZED;
-        }
-
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_RAW,
-                "NFC_RAW permission required to open NFC P2P connection");
-        if (!mOpenPending) {
-            NativeP2pDevice device;
-            mOpenPending = true;
-            device = mManager.doOpenP2pConnection(mTimeout);
-            if (device != null) {
-                /* add device to the Hmap */
-                mObjectMap.put(device.getHandle(), device);
-                return device.getHandle();
-            } else {
-                mOpenPending = false;
-                /* Restart polling loop for notification */
-                mManager.enableDiscovery(DISCOVERY_MODE_READER);
-                return ErrorCodes.ERROR_IO;
-            }
-        } else {
-            return ErrorCodes.ERROR_BUSY;
-        }
-
-    }
-
-    public void openTagConnection(Tag tag) throws RemoteException {
-        NativeNfcTag nativeTag = new NativeNfcTag(tag.getHandle(), "", tag.getId());
-
-        mObjectMap.put(nativeTag.getHandle(), nativeTag);
-    }
-
-    public int selectSecureElement(int seId) throws RemoteException {
-        // Check if NFC is enabled
-        if (!mIsNfcEnabled) {
-            return ErrorCodes.ERROR_NOT_INITIALIZED;
-        }
-
-        if (mSelectedSeId == seId) {
-            return ErrorCodes.ERROR_SE_ALREADY_SELECTED;
-        }
-
-        if (mSelectedSeId != 0) {
-            return ErrorCodes.ERROR_SE_CONNECTED;
-        }
-
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_ADMIN,
-                "NFC_ADMIN permission required to select NFC Secure Element");
-
-            mSelectedSeId = seId;
-            mManager.doSelectSecureElement(mSelectedSeId);
-
-        /* Store that a secure element is selected */
-        Settings.System.putInt(mContext.getContentResolver(),
-                Settings.System.NFC_SECURE_ELEMENT_ON, 1);
-
-        /* Store the ID of the Secure Element Selected */
-        Settings.System.putInt(mContext.getContentResolver(),
-                Settings.System.NFC_SECURE_ELEMENT_ID, mSelectedSeId);
-
-        mNfcSecureElementState = 1;
-
-        return ErrorCodes.SUCCESS;
-
-    }
-
-    public void setOpenTimeout(int timeout) throws RemoteException {
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_RAW,
-                "NFC_RAW permission required to set NFC connection timeout");
-        mTimeout = timeout;
-    }
-
-    public int setProperties(String param, String value) throws RemoteException {
-        mContext.enforceCallingPermission(android.Manifest.permission.NFC_ADMIN,
-                "NFC_ADMIN permission required to set NFC Properties");
-
-        if (isEnabled()) {
-            return ErrorCodes.ERROR_NFC_ON;
-        }
-
-        int val;
-
-        /* Check params validity */
-        if (param == null || value == null) {
-            return ErrorCodes.ERROR_INVALID_PARAM;
-        }
-
-        if (param.equals(PROPERTY_LLCP_LTO_VALUE)) {
-            val = Integer.parseInt(value);
-
-            /* Check params */
-            if (val > LLCP_LTO_MAX_VALUE)
-                return ErrorCodes.ERROR_INVALID_PARAM;
-
-            /* Store value */
-            Settings.System
-                    .putInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_LTO, val);
-
-            /* Update JNI */
-            mManager.doSetProperties(PROPERTY_LLCP_LTO, val);
-
-        } else if (param.equals(PROPERTY_LLCP_MIU_VALUE)) {
-            val = Integer.parseInt(value);
-
-            /* Check params */
-            if ((val < LLCP_MIU_DEFAULT_VALUE) || (val > LLCP_MIU_MAX_VALUE))
-                return ErrorCodes.ERROR_INVALID_PARAM;
-
-            /* Store value */
-            Settings.System
-                    .putInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_MIU, val);
-
-            /* Update JNI */
-            mManager.doSetProperties(PROPERTY_LLCP_MIU, val);
-
-        } else if (param.equals(PROPERTY_LLCP_WKS_VALUE)) {
-            val = Integer.parseInt(value);
-
-            /* Check params */
-            if (val > LLCP_WKS_MAX_VALUE)
-                return ErrorCodes.ERROR_INVALID_PARAM;
-
-            /* Store value */
-            Settings.System
-                    .putInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_WKS, val);
-
-            /* Update JNI */
-            mManager.doSetProperties(PROPERTY_LLCP_WKS, val);
-
-        } else if (param.equals(PROPERTY_LLCP_OPT_VALUE)) {
-            val = Integer.parseInt(value);
-
-            /* Check params */
-            if (val > LLCP_OPT_MAX_VALUE)
-                return ErrorCodes.ERROR_INVALID_PARAM;
-
-            /* Store value */
-            Settings.System
-                    .putInt(mContext.getContentResolver(), Settings.System.NFC_LLCP_OPT, val);
-
-            /* Update JNI */
-            mManager.doSetProperties(PROPERTY_LLCP_OPT, val);
-
-        } else if (param.equals(PROPERTY_NFC_DISCOVERY_A_VALUE)) {
-
-            /* Check params */
-            if (value.equals("true")) {
-                val = 1;
-            } else if (value.equals("false")) {
-                val = 0;
-            } else {
-                return ErrorCodes.ERROR_INVALID_PARAM;
-            }
-            /* Store value */
-            Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_DISCOVERY_A,
-                    val);
-
-            /* Update JNI */
-            mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_A, val);
-
-        } else if (param.equals(PROPERTY_NFC_DISCOVERY_B_VALUE)) {
-
-            /* Check params */
-            if (value.equals("true")) {
-                val = 1;
-            } else if (value.equals("false")) {
-                val = 0;
-            } else {
-                return ErrorCodes.ERROR_INVALID_PARAM;
-            }
-
-            /* Store value */
-            Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_DISCOVERY_B,
-                    val);
-
-            /* Update JNI */
-            mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_B, val);
-
-        } else if (param.equals(PROPERTY_NFC_DISCOVERY_F_VALUE)) {
-
-            /* Check params */
-            if (value.equals("true")) {
-                val = 1;
-            } else if (value.equals("false")) {
-                val = 0;
-            } else {
-                return ErrorCodes.ERROR_INVALID_PARAM;
-            }
-
-            /* Store value */
-            Settings.System.putInt(mContext.getContentResolver(), Settings.System.NFC_DISCOVERY_F,
-                    val);
-
-            /* Update JNI */
-            mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_F, val);
-
-        } else if (param.equals(PROPERTY_NFC_DISCOVERY_15693_VALUE)) {
-
-            /* Check params */
-            if (value.equals("true")) {
-                val = 1;
-            } else if (value.equals("false")) {
-                val = 0;
-            } else {
-                return ErrorCodes.ERROR_INVALID_PARAM;
-            }
-
-            /* Store value */
-            Settings.System.putInt(mContext.getContentResolver(),
-                    Settings.System.NFC_DISCOVERY_15693, val);
-
-            /* Update JNI */
-            mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_15693, val);
-
-        } else if (param.equals(PROPERTY_NFC_DISCOVERY_NFCIP_VALUE)) {
-
-            /* Check params */
-            if (value.equals("true")) {
-                val = 1;
-            } else if (value.equals("false")) {
-                val = 0;
-            } else {
-                return ErrorCodes.ERROR_INVALID_PARAM;
-            }
-
-            /* Store value */
-            Settings.System.putInt(mContext.getContentResolver(),
-                    Settings.System.NFC_DISCOVERY_NFCIP, val);
-
-            /* Update JNI */
-            mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_NFCIP, val);
-        } else {
-            return ErrorCodes.ERROR_INVALID_PARAM;
-        }
-
-        return ErrorCodes.SUCCESS;
-    }
-
-    public NdefMessage localGet() throws RemoteException {
-        // TODO Auto-generated method stub
-        return null;
-    }
-
-    public void localSet(NdefMessage message) throws RemoteException {
-        // TODO Auto-generated method stub
-
-    }
-
-    // Reset all internals
-    private void reset() {
-
-        // Clear tables
-        mObjectMap.clear();
-        mSocketMap.clear();
-        mRegisteredSocketList.clear();
-
-        // Reset variables
-        mLlcpLinkState = NfcAdapter.LLCP_LINK_STATE_DEACTIVATED;
-        mNbSocketCreated = 0;
-        mIsNfcEnabled = false;
-        mSelectedSeId = 0;
-        mTimeout = 0;
-        mNfcState = NFC_STATE_DISABLED;
-        mOpenPending = false;
-    }
-
-    private Object findObject(int key) {
-        Object device = null;
-
-        device = mObjectMap.get(key);
-        if (device == null) {
-            Log.w(TAG, "Handle not found !");
-        }
-
-        return device;
-    }
-
-    private void RemoveObject(int key) {
-        mObjectMap.remove(key);
-    }
-
-    private Object findSocket(int key) {
-        Object socket = null;
-
-        socket = mSocketMap.get(key);
-
-        return socket;
-    }
-
-    private void RemoveSocket(int key) {
-        mSocketMap.remove(key);
-    }
-
-    private boolean CheckSocketSap(int sap) {
-        /* List of sockets registered */
-        ListIterator<RegisteredSocket> it = mRegisteredSocketList.listIterator();
-
-        while (it.hasNext()) {
-            RegisteredSocket registeredSocket = it.next();
-
-            if (sap == registeredSocket.mSap) {
-                /* SAP already used */
-                return false;
-            }
-        }
-        return true;
-    }
-
-    private boolean CheckSocketOptions(int miu, int rw, int linearBufferlength) {
-
-        if (rw > LLCP_RW_MAX_VALUE || miu < LLCP_MIU_DEFAULT_VALUE || linearBufferlength < miu) {
-            return false;
-        }
-        return true;
-    }
-
-    private boolean CheckSocketServiceName(String sn) {
-
-        /* List of sockets registered */
-        ListIterator<RegisteredSocket> it = mRegisteredSocketList.listIterator();
-
-        while (it.hasNext()) {
-            RegisteredSocket registeredSocket = it.next();
-
-            if (sn.equals(registeredSocket.mServiceName)) {
-                /* Service Name already used */
-                return false;
-            }
-        }
-        return true;
-    }
-
-    private void RemoveRegisteredSocket(int nativeHandle) {
-        /* check if sockets are registered */
-        ListIterator<RegisteredSocket> it = mRegisteredSocketList.listIterator();
-
-        while (it.hasNext()) {
-            RegisteredSocket registeredSocket = it.next();
-            if (registeredSocket.mHandle == nativeHandle) {
-                /* remove the registered socket from the list */
-                it.remove();
-                Log.d(TAG, "socket removed");
-            }
-        }
-    }
-
-    /*
-     * RegisteredSocket class to store the creation request of socket until the
-     * LLCP link in not activated
-     */
-    private class RegisteredSocket {
-        private final int mType;
-
-        private final int mHandle;
-
-        private final int mSap;
-
-        private int mMiu;
-
-        private int mRw;
-
-        private String mServiceName;
-
-        private int mlinearBufferLength;
-
-        RegisteredSocket(int type, int handle, int sap, String sn, int miu, int rw,
-                int linearBufferLength) {
-            mType = type;
-            mHandle = handle;
-            mSap = sap;
-            mServiceName = sn;
-            mRw = rw;
-            mMiu = miu;
-            mlinearBufferLength = linearBufferLength;
-        }
-
-        RegisteredSocket(int type, int handle, int sap, int miu, int rw, int linearBufferLength) {
-            mType = type;
-            mHandle = handle;
-            mSap = sap;
-            mRw = rw;
-            mMiu = miu;
-            mlinearBufferLength = linearBufferLength;
-        }
-
-        RegisteredSocket(int type, int handle, int sap) {
-            mType = type;
-            mHandle = handle;
-            mSap = sap;
-        }
-    }
-
-    private final BroadcastReceiver mNfcServiceReceiver = new BroadcastReceiver() {
-        @Override
-        public void onReceive(Context context, Intent intent) {
-            Log.d(TAG, "Internal NFC Intent received");
-
-            /* LLCP Link deactivation */
-            if (intent.getAction().equals(NfcAdapter.ACTION_LLCP_LINK_STATE_CHANGED)) {
-                mLlcpLinkState = intent.getIntExtra(NfcAdapter.EXTRA_LLCP_LINK_STATE_CHANGED,
-                        NfcAdapter.LLCP_LINK_STATE_DEACTIVATED);
-
-                if (mLlcpLinkState == NfcAdapter.LLCP_LINK_STATE_DEACTIVATED) {
-                    /* restart polling loop */
-                    mManager.enableDiscovery(DISCOVERY_MODE_READER);
-                }
-
-            }
-            /* LLCP Link activation */
-            else if (intent.getAction().equals(
-                    NativeNfcManager.INTERNAL_LLCP_LINK_STATE_CHANGED_ACTION)) {
-
-                mLlcpLinkState = intent.getIntExtra(
-                        NativeNfcManager.INTERNAL_LLCP_LINK_STATE_CHANGED_EXTRA,
-                        NfcAdapter.LLCP_LINK_STATE_DEACTIVATED);
-
-                if (mLlcpLinkState == NfcAdapter.LLCP_LINK_STATE_ACTIVATED) {
-                    /* check if sockets are registered */
-                    ListIterator<RegisteredSocket> it = mRegisteredSocketList.listIterator();
-
-                    Log.d(TAG, "Nb socket resgistered = " + mRegisteredSocketList.size());
-
-                    while (it.hasNext()) {
-                        RegisteredSocket registeredSocket = it.next();
-
-                        switch (registeredSocket.mType) {
-                            case LLCP_SERVICE_SOCKET_TYPE:
-                                Log.d(TAG, "Registered Llcp Service Socket");
-                                NativeLlcpServiceSocket serviceSocket;
-
-                                serviceSocket = mManager.doCreateLlcpServiceSocket(
-                                        registeredSocket.mSap, registeredSocket.mServiceName,
-                                        registeredSocket.mMiu, registeredSocket.mRw,
-                                        registeredSocket.mlinearBufferLength);
-
-                                if (serviceSocket != null) {
-                                    /* Add the socket into the socket map */
-                                    mSocketMap.put(registeredSocket.mHandle, serviceSocket);
-                                } else {
-                                    /*
-                                     * socket creation error - update the socket
-                                     * handle counter
-                                     */
-                                    mGeneratedSocketHandle -= 1;
-                                }
-                                break;
-
-                            case LLCP_SOCKET_TYPE:
-                                Log.d(TAG, "Registered Llcp Socket");
-                                NativeLlcpSocket clientSocket;
-                                clientSocket = mManager.doCreateLlcpSocket(registeredSocket.mSap,
-                                        registeredSocket.mMiu, registeredSocket.mRw,
-                                        registeredSocket.mlinearBufferLength);
-                                if (clientSocket != null) {
-                                    /* Add the socket into the socket map */
-                                    mSocketMap.put(registeredSocket.mHandle, clientSocket);
-                                } else {
-                                    /*
-                                     * socket creation error - update the socket
-                                     * handle counter
-                                     */
-                                    mGeneratedSocketHandle -= 1;
-                                }
-                                break;
-
-                            case LLCP_CONNECTIONLESS_SOCKET_TYPE:
-                                Log.d(TAG, "Registered Llcp Connectionless Socket");
-                                NativeLlcpConnectionlessSocket connectionlessSocket;
-                                connectionlessSocket = mManager
-                                        .doCreateLlcpConnectionlessSocket(registeredSocket.mSap);
-                                if (connectionlessSocket != null) {
-                                    /* Add the socket into the socket map */
-                                    mSocketMap.put(registeredSocket.mHandle, connectionlessSocket);
-                                } else {
-                                    /*
-                                     * socket creation error - update the socket
-                                     * handle counter
-                                     */
-                                    mGeneratedSocketHandle -= 1;
-                                }
-                                break;
-
-                        }
-                    }
-
-                    /* Remove all registered socket from the list */
-                    mRegisteredSocketList.clear();
-
-                    /* Broadcast Intent Link LLCP activated */
-                    Intent LlcpLinkIntent = new Intent();
-                    LlcpLinkIntent.setAction(NfcAdapter.ACTION_LLCP_LINK_STATE_CHANGED);
-
-                    LlcpLinkIntent.putExtra(NfcAdapter.EXTRA_LLCP_LINK_STATE_CHANGED,
-                            NfcAdapter.LLCP_LINK_STATE_ACTIVATED);
-
-                    Log.d(TAG, "Broadcasting LLCP activation");
-                    mContext.sendOrderedBroadcast(LlcpLinkIntent,
-                            android.Manifest.permission.NFC_LLCP);
-                }
-            }
-            /* Target Deactivated */
-            else if (intent.getAction().equals(
-                    NativeNfcManager.INTERNAL_TARGET_DESELECTED_ACTION)) {
-                if(mOpenPending != false){
-                    mOpenPending = false;
-                }
-                /* Restart polling loop for notification */
-                mManager.enableDiscovery(DISCOVERY_MODE_READER);
-
-            }
-        }
-    };
-}
\ No newline at end of file