| /* |
| * 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.android.nfc; |
| |
| import com.android.internal.nfc.LlcpServiceSocket; |
| import com.android.internal.nfc.LlcpSocket; |
| import com.android.nfc.RegisteredComponentCache.ComponentInfo; |
| import com.android.nfc.ndefpush.NdefPushClient; |
| import com.android.nfc.ndefpush.NdefPushServer; |
| import com.android.nfc3.R; |
| |
| import android.app.Activity; |
| import android.app.ActivityManagerNative; |
| import android.app.Application; |
| import android.app.IActivityManager; |
| import android.app.PendingIntent; |
| import android.app.PendingIntent.CanceledException; |
| import android.app.StatusBarManager; |
| import android.content.ActivityNotFoundException; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.SharedPreferences; |
| import android.content.pm.PackageManager; |
| import android.content.pm.ResolveInfo; |
| import android.content.pm.PackageManager; |
| import android.net.Uri; |
| import android.nfc.ApduList; |
| import android.nfc.ErrorCodes; |
| import android.nfc.FormatException; |
| import android.nfc.ILlcpConnectionlessSocket; |
| import android.nfc.ILlcpServiceSocket; |
| import android.nfc.ILlcpSocket; |
| import android.nfc.INdefPushCallback; |
| import android.nfc.INfcAdapter; |
| import android.nfc.INfcAdapterExtras; |
| import android.nfc.INfcTag; |
| import android.nfc.IP2pInitiator; |
| import android.nfc.IP2pTarget; |
| import android.nfc.LlcpPacket; |
| import android.nfc.NdefMessage; |
| import android.nfc.NdefRecord; |
| import android.nfc.NfcAdapter; |
| import android.nfc.Tag; |
| import android.nfc.TechListParcel; |
| import android.nfc.TransceiveResult; |
| import android.os.AsyncTask; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.os.Message; |
| import android.os.PowerManager; |
| import android.os.RemoteException; |
| import android.os.ServiceManager; |
| import android.util.Log; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.DataInputStream; |
| import java.io.DataOutputStream; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.nio.charset.Charsets; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| public class NfcService extends Application { |
| private static final String ACTION_MASTER_CLEAR_NOTIFICATION = "android.intent.action.MASTER_CLEAR_NOTIFICATION"; |
| |
| static final boolean DBG = false; |
| |
| private static final String MY_TAG_FILE_NAME = "mytag"; |
| private static final String TEAR_DOWN_SCRIPTS_FILE_NAME = "teardowns"; |
| |
| static { |
| System.loadLibrary("nfc_jni"); |
| } |
| |
| /** |
| * NFC Forum "URI Record Type Definition" |
| * |
| * This is a mapping of "URI Identifier Codes" to URI string prefixes, |
| * per section 3.2.2 of the NFC Forum URI Record Type Definition document. |
| */ |
| private static final String[] URI_PREFIX_MAP = new String[] { |
| "", // 0x00 |
| "http://www.", // 0x01 |
| "https://www.", // 0x02 |
| "http://", // 0x03 |
| "https://", // 0x04 |
| "tel:", // 0x05 |
| "mailto:", // 0x06 |
| "ftp://anonymous:anonymous@", // 0x07 |
| "ftp://ftp.", // 0x08 |
| "ftps://", // 0x09 |
| "sftp://", // 0x0A |
| "smb://", // 0x0B |
| "nfs://", // 0x0C |
| "ftp://", // 0x0D |
| "dav://", // 0x0E |
| "news:", // 0x0F |
| "telnet://", // 0x10 |
| "imap:", // 0x11 |
| "rtsp://", // 0x12 |
| "urn:", // 0x13 |
| "pop:", // 0x14 |
| "sip:", // 0x15 |
| "sips:", // 0x16 |
| "tftp:", // 0x17 |
| "btspp://", // 0x18 |
| "btl2cap://", // 0x19 |
| "btgoep://", // 0x1A |
| "tcpobex://", // 0x1B |
| "irdaobex://", // 0x1C |
| "file://", // 0x1D |
| "urn:epc:id:", // 0x1E |
| "urn:epc:tag:", // 0x1F |
| "urn:epc:pat:", // 0x20 |
| "urn:epc:raw:", // 0x21 |
| "urn:epc:", // 0x22 |
| }; |
| |
| public static final String SERVICE_NAME = "nfc"; |
| |
| private static final String TAG = "NfcService"; |
| |
| private static final String NFC_PERM = android.Manifest.permission.NFC; |
| private static final String NFC_PERM_ERROR = "NFC permission required"; |
| private static final String ADMIN_PERM = android.Manifest.permission.WRITE_SECURE_SETTINGS; |
| private static final String ADMIN_PERM_ERROR = "WRITE_SECURE_SETTINGS permission required"; |
| // STOPSHIP: This needs to be updated to the line below |
| // private static final String NFCEE_ADMIN_PERM = "com.android.nfc.permission.NFCEE_ADMIN"; |
| private static final String NFCEE_ADMIN_PERM = NFC_PERM; |
| private static final String NFCEE_ADMIN_PERM_ERROR = "NFCEE_ADMIN permission required"; |
| |
| /*package*/ static final String PREF = "NfcServicePrefs"; |
| |
| private static final String PREF_NFC_ON = "nfc_on"; |
| private static final boolean NFC_ON_DEFAULT = true; |
| |
| private static final String PREF_LLCP_LTO = "llcp_lto"; |
| private static final int LLCP_LTO_DEFAULT = 150; |
| private static final int LLCP_LTO_MAX = 255; |
| |
| /** Maximum Information Unit */ |
| private static final String PREF_LLCP_MIU = "llcp_miu"; |
| private static final int LLCP_MIU_DEFAULT = 128; |
| private static final int LLCP_MIU_MAX = 2176; |
| |
| /** Well Known Service List */ |
| private static final String PREF_LLCP_WKS = "llcp_wks"; |
| private static final int LLCP_WKS_DEFAULT = 1; |
| private static final int LLCP_WKS_MAX = 15; |
| |
| private static final String PREF_LLCP_OPT = "llcp_opt"; |
| private static final int LLCP_OPT_DEFAULT = 0; |
| private static final int LLCP_OPT_MAX = 3; |
| |
| private static final String PREF_DISCOVERY_A = "discovery_a"; |
| private static final boolean DISCOVERY_A_DEFAULT = true; |
| |
| private static final String PREF_DISCOVERY_B = "discovery_b"; |
| private static final boolean DISCOVERY_B_DEFAULT = true; |
| |
| private static final String PREF_DISCOVERY_F = "discovery_f"; |
| private static final boolean DISCOVERY_F_DEFAULT = true; |
| |
| private static final String PREF_DISCOVERY_15693 = "discovery_15693"; |
| private static final boolean DISCOVERY_15693_DEFAULT = true; |
| |
| private static final String PREF_DISCOVERY_NFCIP = "discovery_nfcip"; |
| private static final boolean DISCOVERY_NFCIP_DEFAULT = true; |
| |
| /** NFC Reader Discovery mode for enableDiscovery() */ |
| private static final int DISCOVERY_MODE_READER = 0; |
| |
| private static final int PROPERTY_LLCP_LTO = 0; |
| private static final String PROPERTY_LLCP_LTO_VALUE = "llcp.lto"; |
| private static final int PROPERTY_LLCP_MIU = 1; |
| private static final String PROPERTY_LLCP_MIU_VALUE = "llcp.miu"; |
| private static final int PROPERTY_LLCP_WKS = 2; |
| private static final String PROPERTY_LLCP_WKS_VALUE = "llcp.wks"; |
| private static final int PROPERTY_LLCP_OPT = 3; |
| private static final String PROPERTY_LLCP_OPT_VALUE = "llcp.opt"; |
| private static final int PROPERTY_NFC_DISCOVERY_A = 4; |
| private static final String PROPERTY_NFC_DISCOVERY_A_VALUE = "discovery.iso14443A"; |
| private static final int PROPERTY_NFC_DISCOVERY_B = 5; |
| private static final String PROPERTY_NFC_DISCOVERY_B_VALUE = "discovery.iso14443B"; |
| private static final int PROPERTY_NFC_DISCOVERY_F = 6; |
| private static final String PROPERTY_NFC_DISCOVERY_F_VALUE = "discovery.felica"; |
| private static final int PROPERTY_NFC_DISCOVERY_15693 = 7; |
| private static final String PROPERTY_NFC_DISCOVERY_15693_VALUE = "discovery.iso15693"; |
| private static final int PROPERTY_NFC_DISCOVERY_NFCIP = 8; |
| private static final String PROPERTY_NFC_DISCOVERY_NFCIP_VALUE = "discovery.nfcip"; |
| |
| static final int MSG_NDEF_TAG = 0; |
| static final int MSG_CARD_EMULATION = 1; |
| static final int MSG_LLCP_LINK_ACTIVATION = 2; |
| static final int MSG_LLCP_LINK_DEACTIVATED = 3; |
| static final int MSG_TARGET_DESELECTED = 4; |
| static final int MSG_SHOW_MY_TAG_ICON = 5; |
| static final int MSG_HIDE_MY_TAG_ICON = 6; |
| static final int MSG_MOCK_NDEF = 7; |
| static final int MSG_SE_FIELD_ACTIVATED = 8; |
| static final int MSG_SE_FIELD_DEACTIVATED = 9; |
| |
| // Copied from com.android.nfc_extras to avoid library dependency |
| // Must keep in sync with com.android.nfc_extras |
| static final int ROUTE_OFF = 1; |
| static final int ROUTE_ON_WHEN_SCREEN_ON = 2; |
| public static final String ACTION_RF_FIELD_ON_DETECTED = |
| "com.android.nfc_extras.action.RF_FIELD_ON_DETECTED"; |
| public static final String ACTION_RF_FIELD_OFF_DETECTED = |
| "com.android.nfc_extras.action.RF_FIELD_OFF_DETECTED"; |
| public static final String ACTION_AID_SELECTED = |
| "com.android.nfc_extras.action.AID_SELECTED"; |
| public static final String EXTRA_AID = "com.android.nfc_extras.extra.AID"; |
| |
| // Locked on mNfcAdapter |
| PendingIntent mDispatchOverrideIntent; |
| IntentFilter[] mDispatchOverrideFilters; |
| String[][] mDispatchOverrideTechLists; |
| |
| // TODO: none of these appear to be synchronized but are |
| // read/written from different threads (notably Binder threads)... |
| private int mGeneratedSocketHandle = 0; |
| private volatile boolean mIsNfcEnabled = false; |
| private boolean mIsDiscoveryOn = false; |
| |
| // NFC Execution Environment |
| // fields below are protected by this |
| private static final int SECURE_ELEMENT_ID = 11259375; //TODO: remove hard-coded value |
| private NativeNfcSecureElement mSecureElement; |
| private OpenSecureElement mOpenEe; // null when EE closed |
| private int mEeRoutingState; // contactless interface routing |
| |
| // fields below are used in multiple threads and protected by synchronized(this) |
| private final HashMap<Integer, Object> mObjectMap = new HashMap<Integer, Object>(); |
| private final HashMap<Integer, Object> mSocketMap = new HashMap<Integer, Object>(); |
| private boolean mScreenOn; |
| |
| // fields below are final after onCreate() |
| Context mContext; |
| private NativeNfcManager mManager; |
| private SharedPreferences mPrefs; |
| private SharedPreferences.Editor mPrefsEditor; |
| private PowerManager.WakeLock mWakeLock; |
| private IActivityManager mIActivityManager; |
| NdefPushClient mNdefPushClient; |
| NdefPushServer mNdefPushServer; |
| RegisteredComponentCache mTechListFilters; |
| |
| private static NfcService sService; |
| |
| private HashMap<String, ApduList> mTearDownApdus = new HashMap<String, ApduList>(); |
| |
| public static void enforceAdminPerm(Context context) { |
| int admin = context.checkCallingOrSelfPermission(ADMIN_PERM); |
| int nfcee = context.checkCallingOrSelfPermission(NFCEE_ADMIN_PERM); |
| if (admin != PackageManager.PERMISSION_GRANTED |
| && nfcee != PackageManager.PERMISSION_GRANTED) { |
| throw new SecurityException(ADMIN_PERM_ERROR); |
| } |
| } |
| |
| public static void enforceNfceeAdminPerm(Context context) { |
| context.enforceCallingOrSelfPermission(NFCEE_ADMIN_PERM, NFCEE_ADMIN_PERM_ERROR); |
| } |
| |
| public static NfcService getInstance() { |
| return sService; |
| } |
| |
| private static boolean isComponentEnabled(PackageManager pm, ResolveInfo info) { |
| boolean enabled = false; |
| ComponentName compname = new ComponentName( |
| info.activityInfo.packageName, info.activityInfo.name); |
| try { |
| // Note that getActivityInfo() will internally call |
| // isEnabledLP() to determine whether the component |
| // enabled. If it's not, null is returned. |
| if (pm.getActivityInfo(compname,0) != null) { |
| enabled = true; |
| } |
| } catch (PackageManager.NameNotFoundException e) { |
| enabled = false; |
| } |
| if (!enabled) { |
| Log.d(TAG, "Component not enabled: " + compname); |
| } |
| return enabled; |
| } |
| |
| @Override |
| public void onCreate() { |
| super.onCreate(); |
| |
| Log.i(TAG, "Starting NFC service"); |
| |
| sService = this; |
| |
| mContext = this; |
| mManager = new NativeNfcManager(mContext, this); |
| mManager.initializeNativeStructure(); |
| |
| mNdefPushClient = new NdefPushClient(this); |
| mNdefPushServer = new NdefPushServer(); |
| |
| mTechListFilters = new RegisteredComponentCache(this, |
| NfcAdapter.ACTION_TECH_DISCOVERED, NfcAdapter.ACTION_TECH_DISCOVERED); |
| |
| mSecureElement = new NativeNfcSecureElement(); |
| |
| mPrefs = mContext.getSharedPreferences(PREF, Context.MODE_PRIVATE); |
| mPrefsEditor = mPrefs.edit(); |
| |
| mIsNfcEnabled = false; // real preference read later |
| |
| PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE); |
| mScreenOn = pm.isScreenOn(); |
| mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "NfcService"); |
| |
| mIActivityManager = ActivityManagerNative.getDefault(); |
| |
| readTearDownApdus(); |
| |
| ServiceManager.addService(SERVICE_NAME, mNfcAdapter); |
| |
| IntentFilter filter = new IntentFilter(NativeNfcManager.INTERNAL_TARGET_DESELECTED_ACTION); |
| filter.addAction(Intent.ACTION_SCREEN_OFF); |
| filter.addAction(Intent.ACTION_SCREEN_ON); |
| filter.addAction(ACTION_MASTER_CLEAR_NOTIFICATION); |
| mContext.registerReceiver(mReceiver, filter); |
| |
| filter = new IntentFilter(); |
| filter.addAction(Intent.ACTION_PACKAGE_REMOVED); |
| filter.addDataScheme("package"); |
| |
| mContext.registerReceiver(mReceiver, filter); |
| |
| Thread t = new Thread() { |
| @Override |
| public void run() { |
| boolean nfc_on = mPrefs.getBoolean(PREF_NFC_ON, NFC_ON_DEFAULT); |
| if (nfc_on) { |
| _enable(false); |
| } |
| } |
| }; |
| t.start(); |
| } |
| |
| @Override |
| public void onTerminate() { |
| super.onTerminate(); |
| // NFC application is persistent, it should not be destroyed by framework |
| Log.wtf(TAG, "NFC service is under attack!"); |
| } |
| |
| private final INfcAdapter.Stub mNfcAdapter = new INfcAdapter.Stub() { |
| /** Protected by "this" */ |
| NdefMessage mLocalMessage = null; |
| |
| @Override |
| public boolean enable() throws RemoteException { |
| NfcService.enforceAdminPerm(mContext); |
| |
| boolean isSuccess = false; |
| boolean previouslyEnabled = isEnabled(); |
| if (!previouslyEnabled) { |
| reset(); |
| isSuccess = _enable(previouslyEnabled); |
| } |
| return isSuccess; |
| } |
| |
| @Override |
| public boolean disable() throws RemoteException { |
| boolean isSuccess = false; |
| NfcService.enforceAdminPerm(mContext); |
| boolean previouslyEnabled = isEnabled(); |
| if (DBG) Log.d(TAG, "Disabling NFC. previous=" + previouslyEnabled); |
| |
| if (previouslyEnabled) { |
| /* tear down the my tag server */ |
| mNdefPushServer.stop(); |
| |
| // Stop watchdog if tag present |
| // A convenient way to stop the watchdog properly consists of |
| // disconnecting the tag. The polling loop shall be stopped before |
| // to avoid the tag being discovered again. |
| mIsDiscoveryOn = false; |
| applyRouting(); |
| maybeDisconnectTarget(); |
| |
| isSuccess = mManager.deinitialize(); |
| if (DBG) Log.d(TAG, "NFC success of deinitialize = " + isSuccess); |
| if (isSuccess) { |
| mIsNfcEnabled = false; |
| // Clear out any old dispatch overrides and NDEF push message |
| synchronized (this) { |
| mDispatchOverrideFilters = null; |
| mDispatchOverrideIntent = null; |
| } |
| mNdefPushClient.setForegroundMessage(null); |
| } |
| } |
| |
| updateNfcOnSetting(previouslyEnabled); |
| |
| return isSuccess; |
| } |
| |
| @Override |
| public void enableForegroundDispatch(ComponentName activity, PendingIntent intent, |
| IntentFilter[] filters, TechListParcel techListsParcel) { |
| // Permission check |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| // Argument validation |
| if (activity == null || intent == null) { |
| throw new IllegalArgumentException(); |
| } |
| |
| // Validate the IntentFilters |
| if (filters != null) { |
| if (filters.length == 0) { |
| filters = null; |
| } else { |
| for (IntentFilter filter : filters) { |
| if (filter == null) { |
| throw new IllegalArgumentException("null IntentFilter"); |
| } |
| } |
| } |
| } |
| |
| // Validate the tech lists |
| String[][] techLists = null; |
| if (techListsParcel != null) { |
| techLists = techListsParcel.getTechLists(); |
| } |
| |
| synchronized (this) { |
| if (mDispatchOverrideIntent != null) { |
| Log.e(TAG, "Replacing active dispatch overrides"); |
| } |
| mDispatchOverrideIntent = intent; |
| mDispatchOverrideFilters = filters; |
| mDispatchOverrideTechLists = techLists; |
| } |
| } |
| |
| @Override |
| public void disableForegroundDispatch(ComponentName activity) { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| synchronized (this) { |
| if (mDispatchOverrideIntent == null) { |
| Log.e(TAG, "No active foreground dispatching"); |
| } |
| mDispatchOverrideIntent = null; |
| mDispatchOverrideFilters = null; |
| } |
| } |
| |
| @Override |
| public void enableForegroundNdefPush(ComponentName activity, NdefMessage msg) { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| if (activity == null || msg == null) { |
| throw new IllegalArgumentException(); |
| } |
| if (mNdefPushClient.setForegroundMessage(msg)) { |
| Log.e(TAG, "Replacing active NDEF push message"); |
| } |
| } |
| |
| @Override |
| public void enableForegroundNdefPushWithCallback(ComponentName activity, |
| INdefPushCallback callback) { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| if (activity == null || callback == null) { |
| throw new IllegalArgumentException(); |
| } |
| if (mNdefPushClient.setForegroundCallback(callback)) { |
| Log.e(TAG, "Replacing active NDEF push message"); |
| } |
| } |
| |
| @Override |
| public void disableForegroundNdefPush(ComponentName activity) { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| boolean hadMsg = mNdefPushClient.setForegroundMessage(null); |
| boolean hadCallback = mNdefPushClient.setForegroundCallback(null); |
| if (!hadMsg || !hadCallback) { |
| Log.e(TAG, "No active foreground NDEF push message"); |
| } |
| } |
| |
| @Override |
| public int createLlcpConnectionlessSocket(int sap) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| /* Check SAP is not already used */ |
| |
| /* Store the socket handle */ |
| int sockeHandle = mGeneratedSocketHandle; |
| NativeLlcpConnectionlessSocket socket; |
| |
| socket = mManager.doCreateLlcpConnectionlessSocket(sap); |
| if (socket != null) { |
| synchronized(NfcService.this) { |
| /* update socket handle generation */ |
| mGeneratedSocketHandle++; |
| |
| /* Add the socket into the socket map */ |
| mSocketMap.put(mGeneratedSocketHandle, socket); |
| return mGeneratedSocketHandle; |
| } |
| } else { |
| /* 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; |
| } |
| } |
| } |
| |
| @Override |
| public int createLlcpServiceSocket(int sap, String sn, int miu, int rw, int linearBufferLength) |
| throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| NativeLlcpServiceSocket socket; |
| |
| socket = mManager.doCreateLlcpServiceSocket(sap, sn, miu, rw, linearBufferLength); |
| if (socket != null) { |
| synchronized(NfcService.this) { |
| /* update socket handle generation */ |
| mGeneratedSocketHandle++; |
| |
| /* Add the socket into the socket map */ |
| mSocketMap.put(mGeneratedSocketHandle, socket); |
| return mGeneratedSocketHandle; |
| } |
| } else { |
| /* 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; |
| } |
| } |
| } |
| |
| @Override |
| public int createLlcpSocket(int sap, int miu, int rw, int linearBufferLength) |
| throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| if (DBG) Log.d(TAG, "creating llcp socket"); |
| NativeLlcpSocket socket; |
| |
| socket = mManager.doCreateLlcpSocket(sap, miu, rw, linearBufferLength); |
| |
| if (socket != null) { |
| synchronized(NfcService.this) { |
| /* update socket handle generation */ |
| mGeneratedSocketHandle++; |
| |
| /* Add the socket into the socket map */ |
| mSocketMap.put(mGeneratedSocketHandle, socket); |
| return mGeneratedSocketHandle; |
| } |
| } else { |
| /* Get Error Status */ |
| int errorStatus = mManager.doGetLastError(); |
| |
| Log.d(TAG, "failed to create llcp socket: " + ErrorCodes.asString(errorStatus)); |
| |
| 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; |
| } |
| } |
| } |
| |
| @Override |
| public ILlcpConnectionlessSocket getLlcpConnectionlessInterface() throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| return mLlcpConnectionlessSocketService; |
| } |
| |
| @Override |
| public ILlcpSocket getLlcpInterface() throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| return mLlcpSocket; |
| } |
| |
| @Override |
| public ILlcpServiceSocket getLlcpServiceInterface() throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| return mLlcpServerSocketService; |
| } |
| |
| @Override |
| public INfcTag getNfcTagInterface() throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| return mNfcTagService; |
| } |
| |
| @Override |
| public IP2pInitiator getP2pInitiatorInterface() throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| return mP2pInitiatorService; |
| } |
| |
| @Override |
| public IP2pTarget getP2pTargetInterface() throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| return mP2pTargetService; |
| } |
| |
| @Override |
| public INfcAdapterExtras getNfcAdapterExtrasInterface() { |
| NfcService.enforceNfceeAdminPerm(mContext); |
| return mExtrasService; |
| } |
| |
| @Override |
| public String getProperties(String param) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| if (param == null) { |
| return null; |
| } |
| |
| if (param.equals(PROPERTY_LLCP_LTO_VALUE)) { |
| return Integer.toString(mPrefs.getInt(PREF_LLCP_LTO, LLCP_LTO_DEFAULT)); |
| } else if (param.equals(PROPERTY_LLCP_MIU_VALUE)) { |
| return Integer.toString(mPrefs.getInt(PREF_LLCP_MIU, LLCP_MIU_DEFAULT)); |
| } else if (param.equals(PROPERTY_LLCP_WKS_VALUE)) { |
| return Integer.toString(mPrefs.getInt(PREF_LLCP_WKS, LLCP_WKS_DEFAULT)); |
| } else if (param.equals(PROPERTY_LLCP_OPT_VALUE)) { |
| return Integer.toString(mPrefs.getInt(PREF_LLCP_OPT, LLCP_OPT_DEFAULT)); |
| } else if (param.equals(PROPERTY_NFC_DISCOVERY_A_VALUE)) { |
| return Boolean.toString(mPrefs.getBoolean(PREF_DISCOVERY_A, DISCOVERY_A_DEFAULT)); |
| } else if (param.equals(PROPERTY_NFC_DISCOVERY_B_VALUE)) { |
| return Boolean.toString(mPrefs.getBoolean(PREF_DISCOVERY_B, DISCOVERY_B_DEFAULT)); |
| } else if (param.equals(PROPERTY_NFC_DISCOVERY_F_VALUE)) { |
| return Boolean.toString(mPrefs.getBoolean(PREF_DISCOVERY_F, DISCOVERY_F_DEFAULT)); |
| } else if (param.equals(PROPERTY_NFC_DISCOVERY_NFCIP_VALUE)) { |
| return Boolean.toString(mPrefs.getBoolean(PREF_DISCOVERY_NFCIP, DISCOVERY_NFCIP_DEFAULT)); |
| } else if (param.equals(PROPERTY_NFC_DISCOVERY_15693_VALUE)) { |
| return Boolean.toString(mPrefs.getBoolean(PREF_DISCOVERY_15693, DISCOVERY_15693_DEFAULT)); |
| } else { |
| return "Unknown property"; |
| } |
| } |
| |
| @Override |
| public boolean isEnabled() throws RemoteException { |
| return mIsNfcEnabled; |
| } |
| |
| @Override |
| public int setProperties(String param, String value) throws RemoteException { |
| NfcService.enforceAdminPerm(mContext); |
| |
| 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) |
| return ErrorCodes.ERROR_INVALID_PARAM; |
| |
| /* Store value */ |
| mPrefsEditor.putInt(PREF_LLCP_LTO, val); |
| mPrefsEditor.apply(); |
| |
| /* 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) || (val > LLCP_MIU_MAX)) |
| return ErrorCodes.ERROR_INVALID_PARAM; |
| |
| /* Store value */ |
| mPrefsEditor.putInt(PREF_LLCP_MIU, val); |
| mPrefsEditor.apply(); |
| |
| /* 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) |
| return ErrorCodes.ERROR_INVALID_PARAM; |
| |
| /* Store value */ |
| mPrefsEditor.putInt(PREF_LLCP_WKS, val); |
| mPrefsEditor.apply(); |
| |
| /* 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) |
| return ErrorCodes.ERROR_INVALID_PARAM; |
| |
| /* Store value */ |
| mPrefsEditor.putInt(PREF_LLCP_OPT, val); |
| mPrefsEditor.apply(); |
| |
| /* Update JNI */ |
| mManager.doSetProperties(PROPERTY_LLCP_OPT, val); |
| |
| } else if (param.equals(PROPERTY_NFC_DISCOVERY_A_VALUE)) { |
| boolean b = Boolean.parseBoolean(value); |
| |
| /* Store value */ |
| mPrefsEditor.putBoolean(PREF_DISCOVERY_A, b); |
| mPrefsEditor.apply(); |
| |
| /* Update JNI */ |
| mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_A, b ? 1 : 0); |
| |
| } else if (param.equals(PROPERTY_NFC_DISCOVERY_B_VALUE)) { |
| boolean b = Boolean.parseBoolean(value); |
| |
| /* Store value */ |
| mPrefsEditor.putBoolean(PREF_DISCOVERY_B, b); |
| mPrefsEditor.apply(); |
| |
| /* Update JNI */ |
| mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_B, b ? 1 : 0); |
| |
| } else if (param.equals(PROPERTY_NFC_DISCOVERY_F_VALUE)) { |
| boolean b = Boolean.parseBoolean(value); |
| |
| /* Store value */ |
| mPrefsEditor.putBoolean(PREF_DISCOVERY_F, b); |
| mPrefsEditor.apply(); |
| |
| /* Update JNI */ |
| mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_F, b ? 1 : 0); |
| |
| } else if (param.equals(PROPERTY_NFC_DISCOVERY_15693_VALUE)) { |
| boolean b = Boolean.parseBoolean(value); |
| |
| /* Store value */ |
| mPrefsEditor.putBoolean(PREF_DISCOVERY_15693, b); |
| mPrefsEditor.apply(); |
| |
| /* Update JNI */ |
| mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_15693, b ? 1 : 0); |
| |
| } else if (param.equals(PROPERTY_NFC_DISCOVERY_NFCIP_VALUE)) { |
| boolean b = Boolean.parseBoolean(value); |
| |
| /* Store value */ |
| mPrefsEditor.putBoolean(PREF_DISCOVERY_NFCIP, b); |
| mPrefsEditor.apply(); |
| |
| /* Update JNI */ |
| mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_NFCIP, b ? 1 : 0); |
| |
| } else { |
| return ErrorCodes.ERROR_INVALID_PARAM; |
| } |
| |
| return ErrorCodes.SUCCESS; |
| } |
| |
| @Override |
| public NdefMessage localGet() throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| synchronized (this) { |
| return mLocalMessage; |
| } |
| } |
| |
| @Override |
| public void localSet(NdefMessage message) throws RemoteException { |
| NfcService.enforceAdminPerm(mContext); |
| |
| synchronized (this) { |
| mLocalMessage = message; |
| Context context = NfcService.this.getApplicationContext(); |
| |
| // Send a message to the UI thread to show or hide the icon so the requests are |
| // serialized and the icon can't get out of sync with reality. |
| if (message != null) { |
| FileOutputStream out = null; |
| |
| try { |
| out = context.openFileOutput(MY_TAG_FILE_NAME, Context.MODE_PRIVATE); |
| byte[] bytes = message.toByteArray(); |
| if (bytes.length == 0) { |
| Log.w(TAG, "Setting a empty mytag"); |
| } |
| |
| out.write(bytes); |
| } catch (IOException e) { |
| Log.e(TAG, "Could not write mytag file", e); |
| } finally { |
| try { |
| if (out != null) { |
| out.flush(); |
| out.close(); |
| } |
| } catch (IOException e) { |
| // Ignore |
| } |
| } |
| |
| // Only show the icon if NFC is enabled. |
| if (mIsNfcEnabled) { |
| sendMessage(MSG_SHOW_MY_TAG_ICON, null); |
| } |
| } else { |
| context.deleteFile(MY_TAG_FILE_NAME); |
| sendMessage(MSG_HIDE_MY_TAG_ICON, null); |
| } |
| } |
| } |
| }; |
| |
| private final ILlcpSocket mLlcpSocket = new ILlcpSocket.Stub() { |
| |
| private NativeLlcpSocket findSocket(int nativeHandle) { |
| Object socket = NfcService.this.findSocket(nativeHandle); |
| if (!(socket instanceof NativeLlcpSocket)) { |
| return null; |
| } |
| return (NativeLlcpSocket) socket; |
| } |
| |
| @Override |
| public int close(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpSocket socket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = findSocket(nativeHandle); |
| if (socket != null) { |
| socket.doClose(); |
| /* Remove the socket closed from the hmap */ |
| RemoveSocket(nativeHandle); |
| return ErrorCodes.SUCCESS; |
| } else { |
| return ErrorCodes.ERROR_IO; |
| } |
| } |
| |
| @Override |
| public int connect(int nativeHandle, int sap) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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 = findSocket(nativeHandle); |
| if (socket != null) { |
| isSuccess = socket.doConnect(sap); |
| if (isSuccess) { |
| return ErrorCodes.SUCCESS; |
| } else { |
| return ErrorCodes.ERROR_IO; |
| } |
| } else { |
| return ErrorCodes.ERROR_IO; |
| } |
| |
| } |
| |
| @Override |
| public int connectByName(int nativeHandle, String sn) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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 = findSocket(nativeHandle); |
| if (socket != null) { |
| isSuccess = socket.doConnectBy(sn); |
| if (isSuccess) { |
| return ErrorCodes.SUCCESS; |
| } else { |
| return ErrorCodes.ERROR_IO; |
| } |
| } else { |
| return ErrorCodes.ERROR_IO; |
| } |
| |
| } |
| |
| @Override |
| public int getLocalSap(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpSocket socket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = findSocket(nativeHandle); |
| if (socket != null) { |
| return socket.getSap(); |
| } else { |
| return 0; |
| } |
| } |
| |
| @Override |
| public int getLocalSocketMiu(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpSocket socket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = findSocket(nativeHandle); |
| if (socket != null) { |
| return socket.getMiu(); |
| } else { |
| return 0; |
| } |
| } |
| |
| @Override |
| public int getLocalSocketRw(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpSocket socket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = findSocket(nativeHandle); |
| if (socket != null) { |
| return socket.getRw(); |
| } else { |
| return 0; |
| } |
| } |
| |
| @Override |
| public int getRemoteSocketMiu(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpSocket socket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = 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; |
| } |
| } |
| |
| @Override |
| public int getRemoteSocketRw(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpSocket socket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = 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; |
| } |
| } |
| |
| @Override |
| public int receive(int nativeHandle, byte[] receiveBuffer) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpSocket socket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = findSocket(nativeHandle); |
| if (socket != null) { |
| return socket.doReceive(receiveBuffer); |
| } else { |
| return 0; |
| } |
| } |
| |
| @Override |
| public int send(int nativeHandle, byte[] data) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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 = findSocket(nativeHandle); |
| if (socket != null) { |
| isSuccess = socket.doSend(data); |
| if (isSuccess) { |
| return ErrorCodes.SUCCESS; |
| } else { |
| return ErrorCodes.ERROR_IO; |
| } |
| } else { |
| return ErrorCodes.ERROR_IO; |
| } |
| } |
| }; |
| |
| private final ILlcpServiceSocket mLlcpServerSocketService = new ILlcpServiceSocket.Stub() { |
| |
| private NativeLlcpServiceSocket findSocket(int nativeHandle) { |
| Object socket = NfcService.this.findSocket(nativeHandle); |
| if (!(socket instanceof NativeLlcpServiceSocket)) { |
| return null; |
| } |
| return (NativeLlcpServiceSocket) socket; |
| } |
| |
| @Override |
| public int accept(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpServiceSocket socket = null; |
| NativeLlcpSocket clientSocket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = findSocket(nativeHandle); |
| if (socket != null) { |
| clientSocket = socket.doAccept(socket.getMiu(), |
| socket.getRw(), socket.getLinearBufferLength()); |
| if (clientSocket != null) { |
| /* Add the socket into the socket map */ |
| synchronized(this) { |
| mGeneratedSocketHandle++; |
| mSocketMap.put(mGeneratedSocketHandle, clientSocket); |
| return mGeneratedSocketHandle; |
| } |
| } else { |
| return ErrorCodes.ERROR_IO; |
| } |
| } else { |
| return ErrorCodes.ERROR_IO; |
| } |
| } |
| |
| @Override |
| public void close(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpServiceSocket socket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = findSocket(nativeHandle); |
| if (socket != null) { |
| socket.doClose(); |
| synchronized (this) { |
| /* Remove the socket closed from the hmap */ |
| RemoveSocket(nativeHandle); |
| } |
| } |
| } |
| }; |
| |
| private final ILlcpConnectionlessSocket mLlcpConnectionlessSocketService = new ILlcpConnectionlessSocket.Stub() { |
| |
| private NativeLlcpConnectionlessSocket findSocket(int nativeHandle) { |
| Object socket = NfcService.this.findSocket(nativeHandle); |
| if (!(socket instanceof NativeLlcpConnectionlessSocket)) { |
| return null; |
| } |
| return (NativeLlcpConnectionlessSocket) socket; |
| } |
| |
| @Override |
| public void close(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpConnectionlessSocket socket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = findSocket(nativeHandle); |
| if (socket != null) { |
| socket.doClose(); |
| /* Remove the socket closed from the hmap */ |
| RemoveSocket(nativeHandle); |
| } |
| } |
| |
| @Override |
| public int getSap(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpConnectionlessSocket socket = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return ErrorCodes.ERROR_NOT_INITIALIZED; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = findSocket(nativeHandle); |
| if (socket != null) { |
| return socket.getSap(); |
| } else { |
| return 0; |
| } |
| } |
| |
| @Override |
| public LlcpPacket receiveFrom(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| NativeLlcpConnectionlessSocket socket = null; |
| LlcpPacket packet; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return null; |
| } |
| |
| /* find the socket in the hmap */ |
| socket = findSocket(nativeHandle); |
| if (socket != null) { |
| packet = socket.doReceiveFrom(socket.getLinkMiu()); |
| if (packet != null) { |
| return packet; |
| } |
| return null; |
| } else { |
| return null; |
| } |
| } |
| |
| @Override |
| public int sendTo(int nativeHandle, LlcpPacket packet) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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 = 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() { |
| |
| @Override |
| public int close(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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) { |
| /* Remove the device from the hmap */ |
| unregisterObject(nativeHandle); |
| tag.disconnect(); |
| return ErrorCodes.SUCCESS; |
| } |
| /* Restart polling loop for notification */ |
| applyRouting(); |
| return ErrorCodes.ERROR_DISCONNECT; |
| } |
| |
| @Override |
| public int connect(int nativeHandle, int technology) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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) { |
| return ErrorCodes.ERROR_DISCONNECT; |
| } |
| |
| // Note that on most tags, all technologies are behind a single |
| // handle. This means that the connect at the lower levels |
| // will do nothing, as the tag is already connected to that handle. |
| if (tag.connect(technology)) { |
| return ErrorCodes.SUCCESS; |
| } else { |
| return ErrorCodes.ERROR_DISCONNECT; |
| } |
| } |
| |
| @Override |
| public int reconnect(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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.reconnect()) { |
| return ErrorCodes.SUCCESS; |
| } else { |
| return ErrorCodes.ERROR_DISCONNECT; |
| } |
| } |
| return ErrorCodes.ERROR_DISCONNECT; |
| } |
| |
| @Override |
| public int[] getTechList(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return null; |
| } |
| |
| /* find the tag in the hmap */ |
| NativeNfcTag tag = (NativeNfcTag) findObject(nativeHandle); |
| if (tag != null) { |
| return tag.getTechList(); |
| } |
| return null; |
| } |
| |
| @Override |
| 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; |
| } |
| |
| @Override |
| public boolean isPresent(int nativeHandle) throws RemoteException { |
| NativeNfcTag tag = null; |
| |
| // Check if NFC is enabled |
| if (!mIsNfcEnabled) { |
| return false; |
| } |
| |
| /* find the tag in the hmap */ |
| tag = (NativeNfcTag) findObject(nativeHandle); |
| if (tag == null) { |
| return false; |
| } |
| |
| return tag.isPresent(); |
| } |
| |
| @Override |
| 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); |
| int[] ndefInfo = new int[2]; |
| if (tag != null) { |
| isSuccess = tag.checkNdef(ndefInfo); |
| } |
| return isSuccess; |
| } |
| |
| @Override |
| public TransceiveResult transceive(int nativeHandle, byte[] data, boolean raw) |
| throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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) { |
| int[] targetLost = new int[1]; |
| response = tag.transceive(data, raw, targetLost); |
| TransceiveResult transResult = new TransceiveResult( |
| (response != null) ? true : false, |
| (targetLost[0] == 1) ? true : false, |
| response); |
| return transResult; |
| } |
| return null; |
| } |
| |
| @Override |
| public NdefMessage ndefRead(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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.read(); |
| if (buf == null) |
| return null; |
| |
| /* Create an NdefMessage */ |
| try { |
| return new NdefMessage(buf); |
| } catch (FormatException e) { |
| return null; |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public int ndefWrite(int nativeHandle, NdefMessage msg) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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.write(msg.toByteArray())) { |
| return ErrorCodes.SUCCESS; |
| } |
| else { |
| return ErrorCodes.ERROR_IO; |
| } |
| |
| } |
| |
| @Override |
| public int getLastError(int nativeHandle) throws RemoteException { |
| return(mManager.doGetLastError()); |
| } |
| |
| @Override |
| public boolean ndefIsWritable(int nativeHandle) throws RemoteException { |
| throw new UnsupportedOperationException(); |
| } |
| |
| @Override |
| public int ndefMakeReadOnly(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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.makeReadonly()) { |
| return ErrorCodes.SUCCESS; |
| } |
| else { |
| return ErrorCodes.ERROR_IO; |
| } |
| } |
| |
| @Override |
| public int formatNdef(int nativeHandle, byte[] key) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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.formatNdef(key)) { |
| return ErrorCodes.SUCCESS; |
| } |
| else { |
| return ErrorCodes.ERROR_IO; |
| } |
| } |
| |
| @Override |
| public void setIsoDepTimeout(int timeout) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| mManager.setIsoDepTimeout(timeout); |
| } |
| |
| @Override |
| public void resetIsoDepTimeout() throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| mManager.resetIsoDepTimeout(); |
| } |
| }; |
| |
| private final IP2pInitiator mP2pInitiatorService = new IP2pInitiator.Stub() { |
| |
| @Override |
| public byte[] getGeneralBytes(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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; |
| } |
| |
| @Override |
| public int getMode(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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; |
| } |
| |
| @Override |
| public byte[] receive(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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 */ |
| applyRouting(); |
| return null; |
| } |
| |
| @Override |
| public boolean send(int nativeHandle, byte[] data) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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() { |
| |
| @Override |
| public int connect(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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; |
| } |
| |
| @Override |
| public boolean disconnect(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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()) { |
| /* remove the device from the hmap */ |
| unregisterObject(nativeHandle); |
| /* Restart polling loop for notification */ |
| applyRouting(); |
| } |
| } |
| return isSuccess; |
| |
| } |
| |
| @Override |
| public byte[] getGeneralBytes(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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; |
| } |
| |
| @Override |
| public int getMode(int nativeHandle) throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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; |
| } |
| |
| @Override |
| public byte[] transceive(int nativeHandle, byte[] data) |
| throws RemoteException { |
| mContext.enforceCallingOrSelfPermission(NFC_PERM, NFC_PERM_ERROR); |
| |
| 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 INfcAdapterExtras mExtrasService = new INfcAdapterExtras.Stub() { |
| private Bundle writeNoException() { |
| Bundle p = new Bundle(); |
| p.putInt("e", 0); |
| return p; |
| } |
| private Bundle writeIoException(IOException e) { |
| Bundle p = new Bundle(); |
| p.putInt("e", -1); |
| p.putString("m", e.getMessage()); |
| return p; |
| } |
| |
| @Override |
| public Bundle open(IBinder b) throws RemoteException { |
| NfcService.enforceNfceeAdminPerm(mContext); |
| |
| Bundle result; |
| try { |
| _open(b); |
| result = writeNoException(); |
| } catch (IOException e) { |
| result = writeIoException(e); |
| } |
| return result; |
| } |
| |
| private void _open(IBinder b) throws IOException, RemoteException { |
| synchronized(NfcService.this) { |
| if (!mIsNfcEnabled) { |
| throw new IOException("NFC adapter is disabled"); |
| } |
| if (mOpenEe != null) { |
| throw new IOException("NFC EE already open"); |
| } |
| |
| int handle = mSecureElement.doOpenSecureElementConnection(); |
| if (handle == 0) { |
| throw new IOException("NFC EE failed to open"); |
| } |
| mManager.doSetIsoDepTimeout(10000); |
| |
| mOpenEe = new OpenSecureElement(getCallingPid(), handle); |
| try { |
| b.linkToDeath(mOpenEe, 0); |
| } catch (RemoteException e) { |
| mOpenEe.binderDied(); |
| } |
| } |
| } |
| |
| @Override |
| public Bundle close() throws RemoteException { |
| NfcService.enforceNfceeAdminPerm(mContext); |
| |
| Bundle result; |
| try { |
| _close(); |
| result = writeNoException(); |
| } catch (IOException e) { |
| result = writeIoException(e); |
| } |
| return result; |
| } |
| |
| void _close() throws IOException, RemoteException { |
| // Blocks until a pending open() or transceive() times out. |
| //TODO: This is incorrect behavior - the close should interrupt pending |
| // operations. However this is not supported by current hardware. |
| |
| synchronized(NfcService.this) { |
| if (!mIsNfcEnabled) { |
| throw new IOException("NFC adapter is disabled"); |
| } |
| if (mOpenEe == null) { |
| throw new IOException("NFC EE closed"); |
| } |
| if (mOpenEe.pid != -1 && getCallingPid() != mOpenEe.pid) { |
| throw new SecurityException("Wrong PID"); |
| } |
| |
| mManager.doResetIsoDepTimeout(); |
| mSecureElement.doDisconnect(mOpenEe.handle); |
| mOpenEe = null; |
| |
| applyRouting(); |
| } |
| } |
| |
| @Override |
| public Bundle transceive(byte[] in) throws RemoteException { |
| NfcService.enforceNfceeAdminPerm(mContext); |
| |
| Bundle result; |
| byte[] out; |
| try { |
| out = _transceive(in); |
| result = writeNoException(); |
| result.putByteArray("out", out); |
| } catch (IOException e) { |
| result = writeIoException(e); |
| } |
| return result; |
| } |
| |
| private byte[] _transceive(byte[] data) throws IOException, RemoteException { |
| synchronized(NfcService.this) { |
| if (!mIsNfcEnabled) { |
| throw new IOException("NFC is not enabled"); |
| } |
| if (mOpenEe == null){ |
| throw new IOException("NFC EE is not open"); |
| } |
| if (getCallingPid() != mOpenEe.pid) { |
| throw new SecurityException("Wrong PID"); |
| } |
| } |
| |
| return mSecureElement.doTransceive(mOpenEe.handle, data); |
| } |
| |
| @Override |
| public int getCardEmulationRoute() throws RemoteException { |
| NfcService.enforceNfceeAdminPerm(mContext); |
| return mEeRoutingState; |
| } |
| |
| @Override |
| public void setCardEmulationRoute(int route) throws RemoteException { |
| NfcService.enforceNfceeAdminPerm(mContext); |
| mEeRoutingState = route; |
| applyRouting(); |
| } |
| |
| @Override |
| public void registerTearDownApdus(String packageName, ApduList apdu) throws RemoteException { |
| NfcService.enforceNfceeAdminPerm(mContext); |
| synchronized(NfcService.this) { |
| mTearDownApdus.put(packageName, apdu); |
| writeTearDownApdusLocked(); |
| } |
| } |
| |
| @Override |
| public void unregisterTearDownApdus(String packageName) throws RemoteException { |
| NfcService.enforceNfceeAdminPerm(mContext); |
| synchronized(NfcService.this) { |
| mTearDownApdus.remove(packageName); |
| writeTearDownApdusLocked(); |
| } |
| } |
| }; |
| |
| /** resources kept while secure element is open */ |
| private class OpenSecureElement implements IBinder.DeathRecipient { |
| public int pid; // pid that opened SE |
| public int handle; // low-level handle |
| public OpenSecureElement(int pid, int handle) { |
| this.pid = pid; |
| this.handle = handle; |
| } |
| @Override |
| public void binderDied() { |
| synchronized (NfcService.this) { |
| if (DBG) Log.d(TAG, "Tracked app " + pid + " died"); |
| pid = -1; |
| try { |
| mExtrasService.close(); |
| } catch (RemoteException e) { /* local call never fails */ } |
| } |
| } |
| } |
| |
| private boolean _enable(boolean oldEnabledState) { |
| applyProperties(); |
| |
| boolean isSuccess = mManager.initialize(); |
| if (isSuccess) { |
| mIsNfcEnabled = true; |
| mIsDiscoveryOn = true; |
| |
| /* Start polling loop */ |
| applyRouting(); |
| |
| /* bring up the my tag server */ |
| mNdefPushServer.start(); |
| |
| } else { |
| mIsNfcEnabled = false; |
| } |
| |
| updateNfcOnSetting(oldEnabledState); |
| |
| return isSuccess; |
| } |
| |
| /** apply NFC discovery and EE routing */ |
| private synchronized void applyRouting() { |
| if (mIsNfcEnabled && mOpenEe == null) { |
| if (mScreenOn) { |
| if (mEeRoutingState == ROUTE_ON_WHEN_SCREEN_ON) { |
| Log.d(TAG, "NFC-EE routing ON"); |
| mManager.doSelectSecureElement(SECURE_ELEMENT_ID); |
| } else { |
| Log.d(TAG, "NFC-EE routing OFF"); |
| mManager.doDeselectSecureElement(SECURE_ELEMENT_ID); |
| } |
| if (mIsDiscoveryOn) { |
| Log.d(TAG, "NFC-C discovery ON"); |
| mManager.enableDiscovery(DISCOVERY_MODE_READER); |
| } else { |
| Log.d(TAG, "NFC-C discovery OFF"); |
| mManager.disableDiscovery(); |
| } |
| } else { |
| Log.d(TAG, "NFC-EE routing OFF"); |
| mManager.doDeselectSecureElement(SECURE_ELEMENT_ID); |
| Log.d(TAG, "NFC-C discovery OFF"); |
| mManager.disableDiscovery(); |
| } |
| } |
| } |
| |
| /** Disconnect any target if present */ |
| private synchronized void maybeDisconnectTarget() { |
| if (mIsNfcEnabled) { |
| Iterator<?> iterator = mObjectMap.values().iterator(); |
| while(iterator.hasNext()) { |
| Object object = iterator.next(); |
| if(object instanceof NativeNfcTag) { |
| // Disconnect from tags |
| NativeNfcTag tag = (NativeNfcTag) object; |
| tag.disconnect(); |
| } |
| else if(object instanceof NativeP2pDevice) { |
| // Disconnect from P2P devices |
| NativeP2pDevice device = (NativeP2pDevice) object; |
| if (device.getMode() == NativeP2pDevice.MODE_P2P_TARGET) { |
| // Remote peer is target, request disconnection |
| device.doDisconnect(); |
| } |
| else { |
| // Remote peer is initiator, we cannot disconnect |
| // Just wait for field removal |
| } |
| } |
| iterator.remove(); |
| } |
| } |
| } |
| |
| private void readTearDownApdus() { |
| FileInputStream input = null; |
| |
| try { |
| input = openFileInput(TEAR_DOWN_SCRIPTS_FILE_NAME); |
| DataInputStream stream = new DataInputStream(input); |
| |
| int packagesSize = stream.readInt(); |
| |
| for (int i = 0 ; i < packagesSize ; i++) { |
| String packageName = stream.readUTF(); |
| ApduList apdu = new ApduList(); |
| |
| int commandsSize = stream.readInt(); |
| |
| for (int j = 0 ; j < commandsSize ; j++) { |
| int length = stream.readInt(); |
| |
| byte[] cmd = new byte[length]; |
| |
| stream.read(cmd); |
| apdu.add(cmd); |
| } |
| |
| mTearDownApdus.put(packageName, apdu); |
| } |
| } catch (FileNotFoundException e) { |
| // Ignore. |
| } catch (IOException e) { |
| Log.e(TAG, "Could not read tear down scripts file: ", e); |
| deleteFile(TEAR_DOWN_SCRIPTS_FILE_NAME); |
| } finally { |
| try { |
| if (input != null) { |
| input.close(); |
| } |
| } catch (IOException e) { |
| // Ignore |
| } |
| } |
| } |
| |
| private void writeTearDownApdusLocked() { |
| FileOutputStream output = null; |
| DataOutputStream stream = null; |
| |
| try { |
| output = openFileOutput(TEAR_DOWN_SCRIPTS_FILE_NAME, Context.MODE_PRIVATE); |
| stream = new DataOutputStream(output); |
| |
| stream.writeInt(mTearDownApdus.size()); |
| |
| for (String packageName : mTearDownApdus.keySet()) { |
| stream.writeUTF(packageName); |
| |
| List<byte[]> commands = mTearDownApdus.get(packageName).get(); |
| stream.writeInt(commands.size()); |
| |
| for (byte[] cmd : commands) { |
| stream.writeInt(cmd.length); |
| stream.write(cmd, 0, cmd.length); |
| } |
| } |
| |
| } catch (IOException e) { |
| } finally { |
| try { |
| if (output != null) { |
| stream.flush(); |
| stream.close(); |
| } |
| } catch (IOException e) { |
| // Ignore |
| } |
| } |
| } |
| |
| private void applyProperties() { |
| mManager.doSetProperties(PROPERTY_LLCP_LTO, mPrefs.getInt(PREF_LLCP_LTO, LLCP_LTO_DEFAULT)); |
| mManager.doSetProperties(PROPERTY_LLCP_MIU, mPrefs.getInt(PREF_LLCP_MIU, LLCP_MIU_DEFAULT)); |
| mManager.doSetProperties(PROPERTY_LLCP_WKS, mPrefs.getInt(PREF_LLCP_WKS, LLCP_WKS_DEFAULT)); |
| mManager.doSetProperties(PROPERTY_LLCP_OPT, mPrefs.getInt(PREF_LLCP_OPT, LLCP_OPT_DEFAULT)); |
| mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_A, |
| mPrefs.getBoolean(PREF_DISCOVERY_A, DISCOVERY_A_DEFAULT) ? 1 : 0); |
| mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_B, |
| mPrefs.getBoolean(PREF_DISCOVERY_B, DISCOVERY_B_DEFAULT) ? 1 : 0); |
| mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_F, |
| mPrefs.getBoolean(PREF_DISCOVERY_F, DISCOVERY_F_DEFAULT) ? 1 : 0); |
| mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_15693, |
| mPrefs.getBoolean(PREF_DISCOVERY_15693, DISCOVERY_15693_DEFAULT) ? 1 : 0); |
| mManager.doSetProperties(PROPERTY_NFC_DISCOVERY_NFCIP, |
| mPrefs.getBoolean(PREF_DISCOVERY_NFCIP, DISCOVERY_NFCIP_DEFAULT) ? 1 : 0); |
| } |
| |
| private void updateNfcOnSetting(boolean oldEnabledState) { |
| mPrefsEditor.putBoolean(PREF_NFC_ON, mIsNfcEnabled); |
| mPrefsEditor.apply(); |
| |
| synchronized(this) { |
| if (oldEnabledState != mIsNfcEnabled) { |
| Intent intent = new Intent(NfcAdapter.ACTION_ADAPTER_STATE_CHANGE); |
| intent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); |
| intent.putExtra(NfcAdapter.EXTRA_NEW_BOOLEAN_STATE, mIsNfcEnabled); |
| mContext.sendBroadcast(intent); |
| } |
| |
| if (mIsNfcEnabled) { |
| |
| Context context = getApplicationContext(); |
| |
| // Set this to null by default. If there isn't a tag on disk |
| // or if there was an error reading the tag then this will cause |
| // the status bar icon to be removed. |
| NdefMessage myTag = null; |
| |
| FileInputStream input = null; |
| |
| try { |
| input = context.openFileInput(MY_TAG_FILE_NAME); |
| ByteArrayOutputStream bytes = new ByteArrayOutputStream(); |
| |
| byte[] buffer = new byte[4096]; |
| int read = 0; |
| while ((read = input.read(buffer)) > 0) { |
| bytes.write(buffer, 0, read); |
| } |
| |
| myTag = new NdefMessage(bytes.toByteArray()); |
| } catch (FileNotFoundException e) { |
| // Ignore. |
| } catch (IOException e) { |
| Log.e(TAG, "Could not read mytag file: ", e); |
| context.deleteFile(MY_TAG_FILE_NAME); |
| } catch (FormatException e) { |
| Log.e(TAG, "Invalid NdefMessage for mytag", e); |
| context.deleteFile(MY_TAG_FILE_NAME); |
| } finally { |
| try { |
| if (input != null) { |
| input.close(); |
| } |
| } catch (IOException e) { |
| // Ignore |
| } |
| } |
| |
| try { |
| mNfcAdapter.localSet(myTag); |
| } catch (RemoteException e) { |
| // Ignore |
| } |
| } else { |
| sendMessage(MSG_HIDE_MY_TAG_ICON, null); |
| } |
| } |
| } |
| |
| // Reset all internals |
| private synchronized void reset() { |
| // TODO: none of these appear to be synchronized but are |
| // read/written from different threads (notably Binder threads)... |
| |
| // Clear tables |
| mObjectMap.clear(); |
| mSocketMap.clear(); |
| |
| // Reset variables |
| mIsNfcEnabled = false; |
| } |
| |
| private synchronized Object findObject(int key) { |
| Object device = null; |
| |
| device = mObjectMap.get(key); |
| if (device == null) { |
| Log.w(TAG, "Handle not found !"); |
| } |
| |
| return device; |
| } |
| |
| synchronized void registerTagObject(NativeNfcTag nativeTag) { |
| mObjectMap.put(nativeTag.getHandle(), nativeTag); |
| } |
| |
| synchronized void unregisterObject(int handle) { |
| mObjectMap.remove(handle); |
| } |
| |
| private synchronized Object findSocket(int key) { |
| if (mSocketMap == null) { |
| return null; |
| } |
| return mSocketMap.get(key); |
| } |
| |
| private void RemoveSocket(int key) { |
| mSocketMap.remove(key); |
| } |
| |
| /** For use by code in this process */ |
| public LlcpSocket createLlcpSocket(int sap, int miu, int rw, int linearBufferLength) { |
| try { |
| int handle = mNfcAdapter.createLlcpSocket(sap, miu, rw, linearBufferLength); |
| if (ErrorCodes.isError(handle)) { |
| Log.e(TAG, "unable to create socket: " + ErrorCodes.asString(handle)); |
| return null; |
| } |
| return new LlcpSocket(mLlcpSocket, handle); |
| } catch (RemoteException e) { |
| // This will never happen since the code is calling into it's own process |
| throw new IllegalStateException("unable to talk to myself", e); |
| } |
| } |
| |
| /** For use by code in this process */ |
| public LlcpServiceSocket createLlcpServiceSocket(int sap, String sn, int miu, int rw, |
| int linearBufferLength) { |
| try { |
| int handle = mNfcAdapter.createLlcpServiceSocket(sap, sn, miu, rw, linearBufferLength); |
| if (ErrorCodes.isError(handle)) { |
| Log.e(TAG, "unable to create socket: " + ErrorCodes.asString(handle)); |
| return null; |
| } |
| return new LlcpServiceSocket(mLlcpServerSocketService, mLlcpSocket, handle); |
| } catch (RemoteException e) { |
| // This will never happen since the code is calling into it's own process |
| throw new IllegalStateException("unable to talk to myself", e); |
| } |
| } |
| |
| private void activateLlcpLink() { |
| /* 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); |
| |
| if (DBG) Log.d(TAG, "Broadcasting LLCP activation"); |
| mContext.sendOrderedBroadcast(LlcpLinkIntent, NFC_PERM); |
| } |
| |
| public void sendMockNdefTag(NdefMessage msg) { |
| sendMessage(MSG_MOCK_NDEF, msg); |
| } |
| |
| void sendMessage(int what, Object obj) { |
| Message msg = mHandler.obtainMessage(); |
| msg.what = what; |
| msg.obj = obj; |
| mHandler.sendMessage(msg); |
| } |
| |
| final class NfcServiceHandler extends Handler { |
| |
| public NdefMessage[] findAndReadNdef(NativeNfcTag nativeTag) { |
| // Try to find NDEF on any of the technologies. |
| int[] technologies = nativeTag.getTechList(); |
| int[] handles = nativeTag.getHandleList(); |
| int techIndex = 0; |
| int lastHandleScanned = 0; |
| boolean ndefFoundAndConnected = false; |
| NdefMessage[] ndefMsgs = null; |
| boolean foundFormattable = false; |
| int formattableHandle = 0; |
| int formattableTechnology = 0; |
| |
| while ((!ndefFoundAndConnected) && (techIndex < technologies.length)) { |
| if (handles[techIndex] != lastHandleScanned) { |
| // We haven't seen this handle yet, connect and checkndef |
| if (nativeTag.connect(technologies[techIndex])) { |
| // Check if this type is NDEF formatable |
| if (!foundFormattable) { |
| if (nativeTag.isNdefFormatable()) { |
| foundFormattable = true; |
| formattableHandle = nativeTag.getConnectedHandle(); |
| formattableTechnology = nativeTag.getConnectedTechnology(); |
| // We'll only add formattable tech if no ndef is |
| // found - this is because libNFC refuses to format |
| // an already NDEF formatted tag. |
| } |
| nativeTag.reconnect(); |
| } // else, already found formattable technology |
| |
| int[] ndefinfo = new int[2]; |
| if (nativeTag.checkNdef(ndefinfo)) { |
| ndefFoundAndConnected = true; |
| boolean generateEmptyNdef = false; |
| |
| int supportedNdefLength = ndefinfo[0]; |
| int cardState = ndefinfo[1]; |
| byte[] buff = nativeTag.read(); |
| if (buff != null) { |
| ndefMsgs = new NdefMessage[1]; |
| try { |
| ndefMsgs[0] = new NdefMessage(buff); |
| nativeTag.addNdefTechnology(ndefMsgs[0], |
| nativeTag.getConnectedHandle(), |
| nativeTag.getConnectedLibNfcType(), |
| nativeTag.getConnectedTechnology(), |
| supportedNdefLength, cardState); |
| nativeTag.reconnect(); |
| } catch (FormatException e) { |
| // Create an intent anyway, without NDEF messages |
| generateEmptyNdef = true; |
| } |
| } else { |
| generateEmptyNdef = true; |
| } |
| |
| if (generateEmptyNdef) { |
| ndefMsgs = new NdefMessage[] { }; |
| nativeTag.addNdefTechnology(null, |
| nativeTag.getConnectedHandle(), |
| nativeTag.getConnectedLibNfcType(), |
| nativeTag.getConnectedTechnology(), |
| supportedNdefLength, cardState); |
| nativeTag.reconnect(); |
| } |
| } // else, no NDEF on this tech, continue loop |
| } else { |
| // Connect failed, tag maybe lost. Try next handle |
| // anyway. |
| } |
| } |
| lastHandleScanned = handles[techIndex]; |
| techIndex++; |
| } |
| if (ndefMsgs == null && foundFormattable) { |
| // Tag is not NDEF yet, and found a formattable target, |
| // so add formattable tech to tech list. |
| nativeTag.addNdefFormatableTechnology( |
| formattableHandle, |
| formattableTechnology); |
| } |
| |
| return ndefMsgs; |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case MSG_MOCK_NDEF: { |
| NdefMessage ndefMsg = (NdefMessage) msg.obj; |
| Tag tag = Tag.createMockTag(new byte[] { 0x00 }, |
| new int[] { }, |
| new Bundle[] { }); |
| Log.d(TAG, "mock NDEF tag, starting corresponding activity"); |
| Log.d(TAG, tag.toString()); |
| dispatchTag(tag, new NdefMessage[] { ndefMsg }); |
| break; |
| } |
| |
| case MSG_NDEF_TAG: |
| if (DBG) Log.d(TAG, "Tag detected, notifying applications"); |
| NativeNfcTag nativeTag = (NativeNfcTag) msg.obj; |
| NdefMessage[] ndefMsgs = findAndReadNdef(nativeTag); |
| |
| if (ndefMsgs != null) { |
| nativeTag.startPresenceChecking(); |
| dispatchNativeTag(nativeTag, ndefMsgs); |
| } else { |
| // No ndef found or connect failed, just try to reconnect and dispatch |
| if (nativeTag.reconnect()) { |
| nativeTag.startPresenceChecking(); |
| dispatchNativeTag(nativeTag, null); |
| } else { |
| Log.w(TAG, "Failed to connect to tag"); |
| nativeTag.disconnect(); |
| } |
| } |
| break; |
| |
| case MSG_CARD_EMULATION: |
| if (DBG) Log.d(TAG, "Card Emulation message"); |
| byte[] aid = (byte[]) msg.obj; |
| /* Send broadcast */ |
| Intent aidIntent = new Intent(); |
| aidIntent.setAction(ACTION_AID_SELECTED); |
| aidIntent.putExtra(EXTRA_AID, aid); |
| if (DBG) Log.d(TAG, "Broadcasting ACTION_AID_SELECTED"); |
| mContext.sendBroadcast(aidIntent, NFCEE_ADMIN_PERM); |
| 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 (DBG) Log.d(TAG, "NativeP2pDevice.MODE_P2P_TARGET"); |
| if (device.doConnect()) { |
| /* Check Llcp compliancy */ |
| if (mManager.doCheckLlcp()) { |
| /* Activate Llcp Link */ |
| if (mManager.doActivateLlcp()) { |
| if (DBG) Log.d(TAG, "Initiator Activate LLCP OK"); |
| // Register P2P device |
| mObjectMap.put(device.getHandle(), device); |
| activateLlcpLink(); |
| } else { |
| /* should not happen */ |
| Log.w(TAG, "Initiator Activate LLCP NOK. Disconnect."); |
| device.doDisconnect(); |
| } |
| |
| } else { |
| if (DBG) Log.d(TAG, "Remote Target does not support LLCP. Disconnect."); |
| device.doDisconnect(); |
| } |
| } else { |
| if (DBG) Log.d(TAG, "Cannot connect remote Target. Polling loop restarted..."); |
| /* The polling loop should have been restarted in failing doConnect */ |
| } |
| |
| } else if (device.getMode() == NativeP2pDevice.MODE_P2P_INITIATOR) { |
| if (DBG) Log.d(TAG, "NativeP2pDevice.MODE_P2P_INITIATOR"); |
| /* Check Llcp compliancy */ |
| if (mManager.doCheckLlcp()) { |
| /* Activate Llcp Link */ |
| if (mManager.doActivateLlcp()) { |
| if (DBG) Log.d(TAG, "Target Activate LLCP OK"); |
| // Register P2P device |
| mObjectMap.put(device.getHandle(), device); |
| activateLlcpLink(); |
| } |
| } else { |
| Log.w(TAG, "checkLlcp failed"); |
| } |
| } |
| break; |
| |
| case MSG_LLCP_LINK_DEACTIVATED: |
| device = (NativeP2pDevice) msg.obj; |
| |
| Log.d(TAG, "LLCP Link Deactivated message. Restart polling loop."); |
| synchronized (NfcService.this) { |
| /* Check if the device has been already unregistered */ |
| if (mObjectMap.remove(device.getHandle()) != null) { |
| /* Disconnect if we are initiator */ |
| if (device.getMode() == NativeP2pDevice.MODE_P2P_TARGET) { |
| if (DBG) Log.d(TAG, "disconnecting from target"); |
| /* Restart polling loop */ |
| device.doDisconnect(); |
| } else { |
| if (DBG) Log.d(TAG, "not disconnecting from initiator"); |
| } |
| } |
| } |
| |
| /* 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_DEACTIVATED); |
| if (DBG) Log.d(TAG, "Broadcasting LLCP deactivation"); |
| mContext.sendOrderedBroadcast(LlcpLinkIntent, NFC_PERM); |
| break; |
| |
| case MSG_TARGET_DESELECTED: |
| /* Broadcast Intent Target Deselected */ |
| if (DBG) Log.d(TAG, "Target Deselected"); |
| Intent TargetDeselectedIntent = new Intent(); |
| TargetDeselectedIntent.setAction(mManager.INTERNAL_TARGET_DESELECTED_ACTION); |
| if (DBG) Log.d(TAG, "Broadcasting Intent"); |
| mContext.sendOrderedBroadcast(TargetDeselectedIntent, NFC_PERM); |
| break; |
| |
| case MSG_SHOW_MY_TAG_ICON: { |
| StatusBarManager sb = (StatusBarManager) getSystemService( |
| Context.STATUS_BAR_SERVICE); |
| sb.setIcon("nfc", R.drawable.stat_sys_nfc, 0); |
| break; |
| } |
| |
| case MSG_HIDE_MY_TAG_ICON: { |
| StatusBarManager sb = (StatusBarManager) getSystemService( |
| Context.STATUS_BAR_SERVICE); |
| sb.removeIcon("nfc"); |
| break; |
| } |
| |
| case MSG_SE_FIELD_ACTIVATED:{ |
| if (DBG) Log.d(TAG, "SE FIELD ACTIVATED"); |
| Intent eventFieldOnIntent = new Intent(); |
| eventFieldOnIntent.setAction(ACTION_RF_FIELD_ON_DETECTED); |
| if (DBG) Log.d(TAG, "Broadcasting Intent"); |
| mContext.sendBroadcast(eventFieldOnIntent, NFCEE_ADMIN_PERM); |
| break; |
| } |
| |
| case MSG_SE_FIELD_DEACTIVATED:{ |
| if (DBG) Log.d(TAG, "SE FIELD DEACTIVATED"); |
| Intent eventFieldOffIntent = new Intent(); |
| eventFieldOffIntent.setAction(ACTION_RF_FIELD_OFF_DETECTED); |
| if (DBG) Log.d(TAG, "Broadcasting Intent"); |
| mContext.sendBroadcast(eventFieldOffIntent, NFCEE_ADMIN_PERM); |
| break; |
| } |
| |
| default: |
| Log.e(TAG, "Unknown message received"); |
| break; |
| } |
| } |
| |
| private Intent buildTagIntent(Tag tag, NdefMessage[] msgs, String action) { |
| Intent intent = new Intent(action); |
| intent.putExtra(NfcAdapter.EXTRA_TAG, tag); |
| intent.putExtra(NfcAdapter.EXTRA_ID, tag.getId()); |
| intent.putExtra(NfcAdapter.EXTRA_NDEF_MESSAGES, msgs); |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| return intent; |
| } |
| |
| private void dispatchNativeTag(NativeNfcTag nativeTag, NdefMessage[] msgs) { |
| Tag tag = new Tag(nativeTag.getUid(), nativeTag.getTechList(), |
| nativeTag.getTechExtras(), nativeTag.getHandle(), mNfcTagService); |
| registerTagObject(nativeTag); |
| if (!dispatchTag(tag, msgs)) { |
| unregisterObject(nativeTag.getHandle()); |
| nativeTag.disconnect(); |
| } |
| } |
| |
| public byte[] concat(byte[]... arrays) { |
| int length = 0; |
| for (byte[] array : arrays) { |
| length += array.length; |
| } |
| byte[] result = new byte[length]; |
| int pos = 0; |
| for (byte[] array : arrays) { |
| System.arraycopy(array, 0, result, pos, array.length); |
| pos += array.length; |
| } |
| return result; |
| } |
| |
| private Uri parseWellKnownUriRecord(NdefRecord record) { |
| byte[] payload = record.getPayload(); |
| |
| /* |
| * payload[0] contains the URI Identifier Code, per the |
| * NFC Forum "URI Record Type Definition" section 3.2.2. |
| * |
| * payload[1]...payload[payload.length - 1] contains the rest of |
| * the URI. |
| */ |
| String prefix = URI_PREFIX_MAP[(payload[0] & 0xff)]; |
| byte[] fullUri = concat(prefix.getBytes(Charsets.UTF_8), |
| Arrays.copyOfRange(payload, 1, payload.length)); |
| return Uri.parse(new String(fullUri, Charsets.UTF_8)); |
| } |
| |
| private boolean setTypeOrDataFromNdef(Intent intent, NdefRecord record) { |
| short tnf = record.getTnf(); |
| byte[] type = record.getType(); |
| try { |
| switch (tnf) { |
| case NdefRecord.TNF_MIME_MEDIA: { |
| intent.setType(new String(type, Charsets.US_ASCII)); |
| return true; |
| } |
| case NdefRecord.TNF_ABSOLUTE_URI: { |
| intent.setData(Uri.parse(new String(record.getPayload(), Charsets.UTF_8))); |
| return true; |
| } |
| case NdefRecord.TNF_WELL_KNOWN: { |
| byte[] payload = record.getPayload(); |
| if (payload == null || payload.length == 0) return false; |
| if (Arrays.equals(type, NdefRecord.RTD_TEXT)) { |
| intent.setType("text/plain"); |
| return true; |
| } else if (Arrays.equals(type, NdefRecord.RTD_SMART_POSTER)) { |
| // Parse the smart poster looking for the URI |
| try { |
| NdefMessage msg = new NdefMessage(record.getPayload()); |
| for (NdefRecord subRecord : msg.getRecords()) { |
| short subTnf = subRecord.getTnf(); |
| if (subTnf == NdefRecord.TNF_WELL_KNOWN |
| && Arrays.equals(subRecord.getType(), |
| NdefRecord.RTD_URI)) { |
| intent.setData(parseWellKnownUriRecord(subRecord)); |
| return true; |
| } else if (subTnf == NdefRecord.TNF_ABSOLUTE_URI) { |
| intent.setData(Uri.parse(new String(subRecord.getPayload(), |
| Charsets.UTF_8))); |
| return true; |
| } |
| } |
| } catch (FormatException e) { |
| return false; |
| } |
| } else if (Arrays.equals(type, NdefRecord.RTD_URI)) { |
| intent.setData(parseWellKnownUriRecord(record)); |
| return true; |
| } |
| return false; |
| } |
| } |
| return false; |
| } catch (Exception e) { |
| Log.e(TAG, "failed to parse record", e); |
| return false; |
| } |
| } |
| |
| /** Returns false if no activities were found to dispatch to */ |
| private boolean dispatchTag(Tag tag, NdefMessage[] msgs) { |
| if (DBG) { |
| Log.d(TAG, "Dispatching tag"); |
| Log.d(TAG, tag.toString()); |
| } |
| |
| IntentFilter[] overrideFilters; |
| PendingIntent overrideIntent; |
| String[][] overrideTechLists; |
| boolean foregroundNdefPush = mNdefPushClient.getForegroundMessage() != null; |
| synchronized (mNfcAdapter) { |
| overrideFilters = mDispatchOverrideFilters; |
| overrideIntent = mDispatchOverrideIntent; |
| overrideTechLists = mDispatchOverrideTechLists; |
| } |
| |
| // First look for dispatch overrides |
| if (overrideIntent != null) { |
| if (DBG) Log.d(TAG, "Attempting to dispatch tag with override"); |
| try { |
| if (dispatchTagInternal(tag, msgs, overrideIntent, overrideFilters, |
| overrideTechLists)) { |
| if (DBG) Log.d(TAG, "Dispatched to override"); |
| return true; |
| } |
| Log.w(TAG, "Dispatch override registered, but no filters matched"); |
| } catch (CanceledException e) { |
| Log.w(TAG, "Dispatch overrides pending intent was canceled"); |
| synchronized (mNfcAdapter) { |
| mDispatchOverrideFilters = null; |
| mDispatchOverrideIntent = null; |
| mDispatchOverrideTechLists = null; |
| } |
| } |
| } |
| |
| // If there is not foreground NDEF push setup try a normal dispatch. |
| // |
| // This is avoided when disabled in the NDEF push case to avoid the situation where each |
| // user has a different app in the foreground, causing each to launch itself on the |
| // remote device and the apps swapping which is in the foreground on each phone. |
| if (!foregroundNdefPush) { |
| try { |
| return dispatchTagInternal(tag, msgs, null, null, null); |
| } catch (CanceledException e) { |
| Log.e(TAG, "CanceledException unexpected here", e); |
| return false; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** Returns true if the tech list filter matches the techs on the tag */ |
| private boolean filterMatch(String[] tagTechs, String[] filterTechs) { |
| if (filterTechs == null || filterTechs.length == 0) return false; |
| |
| for (String tech : filterTechs) { |
| if (Arrays.binarySearch(tagTechs, tech) < 0) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| // Dispatch to either an override pending intent or a standard startActivity() |
| private boolean dispatchTagInternal(Tag tag, NdefMessage[] msgs, |
| PendingIntent overrideIntent, IntentFilter[] overrideFilters, |
| String[][] overrideTechLists) |
| throws CanceledException{ |
| Intent intent; |
| |
| // |
| // Try the NDEF content specific dispatch |
| // |
| if (msgs != null && msgs.length > 0) { |
| NdefMessage msg = msgs[0]; |
| NdefRecord[] records = msg.getRecords(); |
| if (records.length > 0) { |
| // Found valid NDEF data, try to dispatch that first |
| NdefRecord record = records[0]; |
| |
| intent = buildTagIntent(tag, msgs, NfcAdapter.ACTION_NDEF_DISCOVERED); |
| if (setTypeOrDataFromNdef(intent, record)) { |
| // The record contains filterable data, try to start a matching activity |
| if (startDispatchActivity(intent, overrideIntent, overrideFilters, |
| overrideTechLists)) { |
| // If an activity is found then skip further dispatching |
| return true; |
| } else { |
| if (DBG) Log.d(TAG, "No activities for NDEF handling of " + intent); |
| } |
| } |
| } |
| } |
| |
| // |
| // Try the technology specific dispatch |
| // |
| String[] tagTechs = tag.getTechList(); |
| Arrays.sort(tagTechs); |
| |
| if (overrideIntent != null) { |
| // There are dispatch overrides in place |
| if (overrideTechLists != null) { |
| for (String[] filterTechs : overrideTechLists) { |
| if (filterMatch(tagTechs, filterTechs)) { |
| // An override matched, send it to the foreground activity. |
| intent = buildTagIntent(tag, msgs, |
| NfcAdapter.ACTION_TECH_DISCOVERED); |
| overrideIntent.send(mContext, Activity.RESULT_OK, intent); |
| return true; |
| } |
| } |
| } |
| } else { |
| // Standard tech dispatch path |
| ArrayList<ResolveInfo> matches = new ArrayList<ResolveInfo>(); |
| ArrayList<ComponentInfo> registered = mTechListFilters.getComponents(); |
| PackageManager pm = getPackageManager(); |
| |
| // Check each registered activity to see if it matches |
| for (ComponentInfo info : registered) { |
| // Don't allow wild card matching |
| if (filterMatch(tagTechs, info.techs) && |
| isComponentEnabled(pm, info.resolveInfo)) { |
| // Add the activity as a match if it's not already in the list |
| if (!matches.contains(info.resolveInfo)) { |
| matches.add(info.resolveInfo); |
| } |
| } |
| } |
| |
| if (matches.size() == 1) { |
| // Single match, launch directly |
| intent = buildTagIntent(tag, msgs, NfcAdapter.ACTION_TECH_DISCOVERED); |
| ResolveInfo info = matches.get(0); |
| intent.setClassName(info.activityInfo.packageName, info.activityInfo.name); |
| try { |
| mContext.startActivity(intent); |
| return true; |
| } catch (ActivityNotFoundException e) { |
| if (DBG) Log.w(TAG, "No activities for technology handling of " + intent); |
| } |
| } else if (matches.size() > 1) { |
| // Multiple matches, show a custom activity chooser dialog |
| intent = new Intent(mContext, TechListChooserActivity.class); |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| intent.putExtra(Intent.EXTRA_INTENT, |
| buildTagIntent(tag, msgs, NfcAdapter.ACTION_TECH_DISCOVERED)); |
| intent.putParcelableArrayListExtra(TechListChooserActivity.EXTRA_RESOLVE_INFOS, |
| matches); |
| try { |
| mContext.startActivity(intent); |
| return true; |
| } catch (ActivityNotFoundException e) { |
| if (DBG) Log.w(TAG, "No activities for technology handling of " + intent); |
| } |
| } else { |
| // No matches, move on |
| if (DBG) Log.w(TAG, "No activities for technology handling"); |
| } |
| } |
| |
| // |
| // Try the generic intent |
| // |
| intent = buildTagIntent(tag, msgs, NfcAdapter.ACTION_TAG_DISCOVERED); |
| if (startDispatchActivity(intent, overrideIntent, overrideFilters, overrideTechLists)) { |
| return true; |
| } else { |
| Log.e(TAG, "No tag fallback activity found for " + intent); |
| return false; |
| } |
| } |
| |
| private boolean startDispatchActivity(Intent intent, PendingIntent overrideIntent, |
| IntentFilter[] overrideFilters, String[][] overrideTechLists) |
| throws CanceledException { |
| if (overrideIntent != null) { |
| boolean found = false; |
| if (overrideFilters == null && overrideTechLists == null) { |
| // No filters means to always dispatch regardless of match |
| found = true; |
| } else if (overrideFilters != null) { |
| for (IntentFilter filter : overrideFilters) { |
| if (filter.match(mContext.getContentResolver(), intent, false, TAG) >= 0) { |
| found = true; |
| break; |
| } |
| } |
| } |
| |
| if (found) { |
| Log.i(TAG, "Dispatching to override intent " + overrideIntent); |
| overrideIntent.send(mContext, Activity.RESULT_OK, intent); |
| return true; |
| } else { |
| return false; |
| } |
| } else { |
| try { |
| // If the current app called stopAppSwitches() then our startActivity() |
| // can be delayed for several seconds. This happens with the default home |
| // screen. As a system service we can override this behavior with |
| // resumeAppSwitches() |
| mIActivityManager.resumeAppSwitches(); |
| } catch (RemoteException e) { } |
| try { |
| mContext.startActivity(intent); |
| return true; |
| } catch (ActivityNotFoundException e) { |
| return false; |
| } |
| } |
| } |
| } |
| |
| private NfcServiceHandler mHandler = new NfcServiceHandler(); |
| |
| private class EnableDisableDiscoveryTask extends AsyncTask<Boolean, Void, Void> { |
| @Override |
| protected Void doInBackground(Boolean... enable) { |
| if (enable != null && enable.length > 0 && enable[0]) { |
| synchronized (NfcService.this) { |
| mScreenOn = true; |
| applyRouting(); |
| } |
| } else { |
| mWakeLock.acquire(); |
| synchronized (NfcService.this) { |
| mScreenOn = false; |
| applyRouting(); |
| maybeDisconnectTarget(); |
| } |
| mWakeLock.release(); |
| } |
| return null; |
| } |
| } |
| |
| private final BroadcastReceiver mReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| if (intent.getAction().equals( |
| NativeNfcManager.INTERNAL_TARGET_DESELECTED_ACTION)) { |
| if (DBG) Log.d(TAG, "INERNAL_TARGET_DESELECTED_ACTION"); |
| |
| /* Restart polling loop for notification */ |
| applyRouting(); |
| |
| } else if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) { |
| // Perform discovery enable in thread to protect against ANR when the |
| // NFC stack wedges. This is *not* the correct way to fix this issue - |
| // configuration of the local NFC adapter should be very quick and should |
| // be safe on the main thread, and the NFC stack should not wedge. |
| new EnableDisableDiscoveryTask().execute(Boolean.TRUE); |
| } else if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) { |
| // Perform discovery disable in thread to protect against ANR when the |
| // NFC stack wedges. This is *not* the correct way to fix this issue - |
| // configuration of the local NFC adapter should be very quick and should |
| // be safe on the main thread, and the NFC stack should not wedge. |
| new EnableDisableDiscoveryTask().execute(new Boolean(false)); |
| } else if (intent.getAction().equals(ACTION_MASTER_CLEAR_NOTIFICATION)) { |
| int handle = mSecureElement.doOpenSecureElementConnection(); |
| if (handle == 0) { |
| Log.e(TAG, "Could not open the secure element!"); |
| return; |
| } |
| |
| synchronized (NfcService.this) { |
| for (String packageName : mTearDownApdus.keySet()) { |
| for (byte[] cmd : mTearDownApdus.get(packageName).get()) { |
| mSecureElement.doTransceive(handle, cmd); |
| } |
| } |
| } |
| |
| mSecureElement.doDisconnect(handle); |
| } else if (intent.getAction().equals(Intent.ACTION_PACKAGE_REMOVED)) { |
| boolean dataRemoved = intent.getBooleanExtra(Intent.EXTRA_DATA_REMOVED, false); |
| if (dataRemoved) { |
| Uri data = intent.getData(); |
| if (data == null) return; |
| String packageName = data.getSchemeSpecificPart(); |
| ApduList apdus = null; |
| |
| synchronized (NfcService.this) { |
| apdus = mTearDownApdus.remove(packageName); |
| if (apdus == null) { |
| return; |
| } |
| |
| |
| writeTearDownApdusLocked(); |
| } |
| |
| int handle = mSecureElement.doOpenSecureElementConnection(); |
| if (handle == 0) { |
| Log.e(TAG, "Could not open the secure element!"); |
| return; |
| } |
| |
| try { |
| for (byte[] cmd : apdus.get()) { |
| mSecureElement.doTransceive(handle, cmd); |
| } |
| } finally { |
| mSecureElement.doDisconnect(handle); |
| } |
| } |
| } |
| } |
| }; |
| } |