* Use the helper {@link #getDefaultAdapter(Context)} to get the default NFC * adapter for this Android device. */ public final class NfcAdapter { static final String TAG = "NFC"; /** * Intent to start an activity when a tag with NDEF payload is discovered. * *
The system inspects the first {@link NdefRecord} in the first {@link NdefMessage} and * looks for a URI, SmartPoster, or MIME record. If a URI or SmartPoster record is found the * intent will contain the URI in its data field. If a MIME record is found the intent will * contain the MIME type in its type field. This allows activities to register * {@link IntentFilter}s targeting specific content on tags. Activities should register the * most specific intent filters possible to avoid the activity chooser dialog, which can * disrupt the interaction with the tag as the user interacts with the screen. * *
If the tag has an NDEF payload this intent is started before * {@link #ACTION_TECH_DISCOVERED}. If any activities respond to this intent neither * {@link #ACTION_TECH_DISCOVERED} or {@link #ACTION_TAG_DISCOVERED} will be started. */ @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) public static final String ACTION_NDEF_DISCOVERED = "android.nfc.action.NDEF_DISCOVERED"; /** * Intent to start an activity when a tag is discovered and activities are registered for the * specific technologies on the tag. * *
To receive this intent an activity must include an intent filter
* for this action and specify the desired tech types in a
* manifest meta-data entry. Here is an example manfiest entry:
*
* <activity android:name=".nfc.TechFilter" android:label="NFC/TechFilter">
* <!-- Add a technology filter -->
* <intent-filter>
* <action android:name="android.nfc.action.TECH_DISCOVERED" />
* </intent-filter>
*
* <meta-data android:name="android.nfc.action.TECH_DISCOVERED"
* android:resource="@xml/filter_nfc"
* />
* </activity>
*
*
* The meta-data XML file should contain one or more tech-list entries
* each consisting or one or more tech entries. The tech entries refer
* to the qualified class name implementing the technology, for example "android.nfc.tech.NfcA".
*
*
A tag matches if any of the
* tech-list sets is a subset of {@link Tag#getTechList() Tag.getTechList()}. Each
* of the tech-lists is considered independently and the
* activity is considered a match is any single tech-list matches the tag that was
* discovered. This provides AND and OR semantics for filtering desired techs. Here is an
* example that will match any tag using {@link NfcF} or any tag using {@link NfcA},
* {@link MifareClassic}, and {@link Ndef}:
*
*
* <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
* <!-- capture anything using NfcF -->
* <tech-list>
* <tech>android.nfc.tech.NfcF</tech>
* </tech-list>
*
* <!-- OR -->
*
* <!-- capture all MIFARE Classics with NDEF payloads -->
* <tech-list>
* <tech>android.nfc.tech.NfcA</tech>
* <tech>android.nfc.tech.MifareClassic</tech>
* <tech>android.nfc.tech.Ndef</tech>
* </tech-list>
* </resources>
*
*
* This intent is started after {@link #ACTION_NDEF_DISCOVERED} and before * {@link #ACTION_TAG_DISCOVERED}. If any activities respond to {@link #ACTION_NDEF_DISCOVERED} * this intent will not be started. If any activities respond to this intent * {@link #ACTION_TAG_DISCOVERED} will not be started. */ @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) public static final String ACTION_TECH_DISCOVERED = "android.nfc.action.TECH_DISCOVERED"; /** * Intent to start an activity when a tag is discovered. * *
This intent will not be started when a tag is discovered if any activities respond to * {@link #ACTION_NDEF_DISCOVERED} or {@link #ACTION_TECH_DISCOVERED} for the current tag. */ @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) public static final String ACTION_TAG_DISCOVERED = "android.nfc.action.TAG_DISCOVERED"; /** * Broadcast to only the activity that handles ACTION_TAG_DISCOVERED * @hide */ public static final String ACTION_TAG_LEFT_FIELD = "android.nfc.action.TAG_LOST"; /** * Mandatory extra containing the {@link Tag} that was discovered for the * {@link #ACTION_NDEF_DISCOVERED}, {@link #ACTION_TECH_DISCOVERED}, and * {@link #ACTION_TAG_DISCOVERED} intents. */ public static final String EXTRA_TAG = "android.nfc.extra.TAG"; /** * Optional extra containing an array of {@link NdefMessage} present on the discovered tag for * the {@link #ACTION_NDEF_DISCOVERED}, {@link #ACTION_TECH_DISCOVERED}, and * {@link #ACTION_TAG_DISCOVERED} intents. */ public static final String EXTRA_NDEF_MESSAGES = "android.nfc.extra.NDEF_MESSAGES"; /** * Optional extra containing a byte array containing the ID of the discovered tag for * the {@link #ACTION_NDEF_DISCOVERED}, {@link #ACTION_TECH_DISCOVERED}, and * {@link #ACTION_TAG_DISCOVERED} intents. */ public static final String EXTRA_ID = "android.nfc.extra.ID"; /** * Broadcast Action: The state of the local NFC adapter has been * changed. *
For example, NFC has been turned on or off. *
Always contains the extra field {@link #EXTRA_STATE} * @hide */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String ACTION_ADAPTER_STATE_CHANGED = "android.nfc.action.ADAPTER_STATE_CHANGED"; /** * Used as an int extra field in {@link #ACTION_STATE_CHANGED} * intents to request the current power state. Possible values are: * {@link #STATE_OFF}, * {@link #STATE_TURNING_ON}, * {@link #STATE_ON}, * {@link #STATE_TURNING_OFF}, * @hide */ public static final String EXTRA_ADAPTER_STATE = "android.nfc.extra.ADAPTER_STATE"; /** @hide */ public static final int STATE_OFF = 1; /** @hide */ public static final int STATE_TURNING_ON = 2; /** @hide */ public static final int STATE_ON = 3; /** @hide */ public static final int STATE_TURNING_OFF = 4; // Guarded by NfcAdapter.class static boolean sIsInitialized = false; // Final after first constructor, except for // attemptDeadServiceRecovery() when NFC crashes - we accept a best effort // recovery static INfcAdapter sService; static INfcTag sTagService; /** * NfcAdapter is currently a singleton, and does not require a context. * However all the public API's are future-proofed to require a context. * If we start using that then we'll need to keep a HashMap of * Context.getApplicationContext() -> NfcAdapter, such that NfcAdapter * is a singleton within each application context. */ static NfcAdapter sSingleton; // protected by NfcAdapter.class final NfcActivityManager mNfcActivityManager; /** * A callback to be invoked when the system successfully delivers your {@link NdefMessage} * to another device. * @see #setOnNdefPushCompleteCallback */ public interface OnNdefPushCompleteCallback { /** * Called on successful NDEF push. * *
This callback is usually made on a binder thread (not the UI thread). * * @param event {@link NfcEvent} with the {@link NfcEvent#nfcAdapter} field set * @see #setNdefPushMessageCallback */ public void onNdefPushComplete(NfcEvent event); } /** * A callback to be invoked when another NFC device capable of NDEF push (Android Beam) * is within range. *
Implement this interface and pass it to {@link * NfcAdapter#setNdefPushMessageCallback setNdefPushMessageCallback()} in order to create an * {@link NdefMessage} at the moment that another device is within range for NFC. Using this * callback allows you to create a message with data that might vary based on the * content currently visible to the user. Alternatively, you can call {@link * #setNdefPushMessage setNdefPushMessage()} if the {@link NdefMessage} always contains the * same data. */ public interface CreateNdefMessageCallback { /** * Called to provide a {@link NdefMessage} to push. * *
This callback is usually made on a binder thread (not the UI thread). * *
Called when this device is in range of another device * that might support NDEF push. It allows the application to * create the NDEF message only when it is required. * *
NDEF push cannot occur until this method returns, so do not * block for too long. * *
The Android operating system will usually show a system UI * on top of your activity during this time, so do not try to request * input from the user to complete the callback, or provide custom NDEF * push UI. The user probably will not see it. * * @param event {@link NfcEvent} with the {@link NfcEvent#nfcAdapter} field set * @return NDEF message to push, or null to not provide a message */ public NdefMessage createNdefMessage(NfcEvent event); } /** * Helper to check if this device has FEATURE_NFC, but without using * a context. * Equivalent to * context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_NFC) */ private static boolean hasNfcFeature() { IPackageManager pm = ActivityThread.getPackageManager(); if (pm == null) { Log.e(TAG, "Cannot get package manager, assuming no NFC feature"); return false; } try { return pm.hasSystemFeature(PackageManager.FEATURE_NFC); } catch (RemoteException e) { Log.e(TAG, "Package manager query failed, assuming no NFC feature", e); return false; } } /** * Returns the singleton, or throws if NFC is not available. */ static synchronized NfcAdapter getSingleton() { if (!sIsInitialized) { sIsInitialized = true; /* is this device meant to have NFC */ if (!hasNfcFeature()) { Log.v(TAG, "this device does not have NFC support"); throw new UnsupportedOperationException(); } sService = getServiceInterface(); if (sService == null) { Log.e(TAG, "could not retrieve NFC service"); throw new UnsupportedOperationException(); } try { sTagService = sService.getNfcTagInterface(); } catch (RemoteException e) { Log.e(TAG, "could not retrieve NFC Tag service"); throw new UnsupportedOperationException(); } sSingleton = new NfcAdapter(); } if (sSingleton == null) { throw new UnsupportedOperationException(); } return sSingleton; } /** get handle to NFC service interface */ private static INfcAdapter getServiceInterface() { /* get a handle to NFC service */ IBinder b = ServiceManager.getService("nfc"); if (b == null) { return null; } return INfcAdapter.Stub.asInterface(b); } /** * Helper to get the default NFC Adapter. *
* Most Android devices will only have one NFC Adapter (NFC Controller). *
* This helper is the equivalent of: *
{@code
* NfcManager manager = (NfcManager) context.getSystemService(Context.NFC_SERVICE);
* NfcAdapter adapter = manager.getDefaultAdapter();
* }
* @param context the calling application's context
*
* @return the default NFC adapter, or null if no NFC adapter exists
*/
public static NfcAdapter getDefaultAdapter(Context context) {
/* use getSystemService() instead of just instantiating to take
* advantage of the context's cached NfcManager & NfcAdapter */
NfcManager manager = (NfcManager) context.getSystemService(Context.NFC_SERVICE);
return manager.getDefaultAdapter();
}
/**
* Get a handle to the default NFC Adapter on this Android device.
* * Most Android devices will only have one NFC Adapter (NFC Controller). * * @return the default NFC adapter, or null if no NFC adapter exists * @deprecated use {@link #getDefaultAdapter(Context)} */ @Deprecated public static NfcAdapter getDefaultAdapter() { Log.w(TAG, "WARNING: NfcAdapter.getDefaultAdapter() is deprecated, use " + "NfcAdapter.getDefaultAdapter(Context) instead", new Exception()); return getSingleton(); } /** * Does not currently need a context. */ NfcAdapter() { mNfcActivityManager = new NfcActivityManager(this); } /** * Returns the binder interface to the service. * @hide */ public INfcAdapter getService() { isEnabled(); // NOP call to recover sService if it is stale return sService; } /** * Returns the binder interface to the tag service. * @hide */ public INfcTag getTagService() { isEnabled(); // NOP call to recover sTagService if it is stale return sTagService; } /** * NFC service dead - attempt best effort recovery * @hide */ public void attemptDeadServiceRecovery(Exception e) { Log.e(TAG, "NFC service dead - attempting to recover", e); INfcAdapter service = getServiceInterface(); if (service == null) { Log.e(TAG, "could not retrieve NFC service during service recovery"); // nothing more can be done now, sService is still stale, we'll hit // this recovery path again later return; } // assigning to sService is not thread-safe, but this is best-effort code // and on a well-behaved system should never happen sService = service; try { sTagService = service.getNfcTagInterface(); } catch (RemoteException ee) { Log.e(TAG, "could not retrieve NFC tag service during service recovery"); // nothing more can be done now, sService is still stale, we'll hit // this recovery path again later } return; } /** * Return true if this NFC Adapter has any features enabled. * *
Application may use this as a helper to suggest that the user * should turn on NFC in Settings. *
If this method returns false, the NFC hardware is guaranteed not to * generate or respond to any NFC transactions. * * @return true if this NFC Adapter has any features enabled */ public boolean isEnabled() { try { return sService.getState() == STATE_ON; } catch (RemoteException e) { attemptDeadServiceRecovery(e); return false; } } /** * Return the state of this NFC Adapter. * *
Returns one of {@link #STATE_ON}, {@link #STATE_TURNING_ON}, * {@link #STATE_OFF}, {@link #STATE_TURNING_OFF}. * *
{@link #isEnabled()} is equivalent to
* {@link #getAdapterState()} == {@link #STATE_ON}
*
* @return the current state of this NFC adapter
*
* @hide
*/
public int getAdapterState() {
try {
return sService.getState();
} catch (RemoteException e) {
attemptDeadServiceRecovery(e);
return NfcAdapter.STATE_OFF;
}
}
/**
* Enable NFC hardware.
*
*
This call is asynchronous. Listen for * {@link #ACTION_ADAPTER_STATE_CHANGED} broadcasts to find out when the * operation is complete. * *
If this returns true, then either NFC is already on, or * a {@link #ACTION_ADAPTER_STATE_CHANGED} broadcast will be sent * to indicate a state transition. If this returns false, then * there is some problem that prevents an attempt to turn * NFC on (for example we are in airplane mode and NFC is not * toggleable in airplane mode on this platform). * * @hide */ public boolean enable() { try { return sService.enable(); } catch (RemoteException e) { attemptDeadServiceRecovery(e); return false; } } /** * Disable NFC hardware. * *
No NFC features will work after this call, and the hardware * will not perform or respond to any NFC communication. * *
This call is asynchronous. Listen for * {@link #ACTION_ADAPTER_STATE_CHANGED} broadcasts to find out when the * operation is complete. * *
If this returns true, then either NFC is already off, or * a {@link #ACTION_ADAPTER_STATE_CHANGED} broadcast will be sent * to indicate a state transition. If this returns false, then * there is some problem that prevents an attempt to turn * NFC off. * * @hide */ public boolean disable() { try { return sService.disable(); } catch (RemoteException e) { attemptDeadServiceRecovery(e); return false; } } /** * Set the {@link NdefMessage} to push over NFC during the specified activities. * *
This method may be called at any time, but the NDEF message is * only made available for NDEF push when one of the specified activities * is in resumed (foreground) state. * *
Only one NDEF message can be pushed by the currently resumed activity. * If both {@link #setNdefPushMessage} and * {@link #setNdefPushMessageCallback} are set then * the callback will take priority. * *
Pass a null NDEF message to disable foreground NDEF push in the * specified activities. * *
At least one activity must be specified, and usually only one is necessary. * *
Requires the {@link android.Manifest.permission#NFC} permission. * * @param message NDEF message to push over NFC, or null to disable * @param activity an activity in which NDEF push should be enabled to share the provided * NDEF message * @param activities optional additional activities that should also enable NDEF push with * the provided NDEF message */ public void setNdefPushMessage(NdefMessage message, Activity activity, Activity ... activities) { if (activity == null) { throw new NullPointerException("activity cannot be null"); } mNfcActivityManager.setNdefPushMessage(activity, message); for (Activity a : activities) { if (a == null) { throw new NullPointerException("activities cannot contain null"); } mNfcActivityManager.setNdefPushMessage(a, message); } } /** * Set the callback to create a {@link NdefMessage} to push over NFC. * *
This method may be called at any time, but this callback is * only made if one of the specified activities * is in resumed (foreground) state. * *
Only one NDEF message can be pushed by the currently resumed activity. * If both {@link #setNdefPushMessage} and * {@link #setNdefPushMessageCallback} are set then * the callback will take priority. * *
Pass a null callback to disable the callback in the * specified activities. * *
At least one activity must be specified, and usually only one is necessary. * *
Requires the {@link android.Manifest.permission#NFC} permission. * * @param callback callback, or null to disable * @param activity an activity in which NDEF push should be enabled to share an NDEF message * that's retrieved from the provided callback * @param activities optional additional activities that should also enable NDEF push using * the provided callback */ public void setNdefPushMessageCallback(CreateNdefMessageCallback callback, Activity activity, Activity ... activities) { if (activity == null) { throw new NullPointerException("activity cannot be null"); } mNfcActivityManager.setNdefPushMessageCallback(activity, callback); for (Activity a : activities) { if (a == null) { throw new NullPointerException("activities cannot contain null"); } mNfcActivityManager.setNdefPushMessageCallback(a, callback); } } /** * Set the callback on a successful NDEF push over NFC. * *
This method may be called at any time, but NDEF push and this callback * can only occur when one of the specified activities is in resumed * (foreground) state. * *
One or more activities must be specified. * *
Requires the {@link android.Manifest.permission#NFC} permission. * * @param callback callback, or null to disable * @param activity an activity to enable the callback (at least one is required) * @param activities zero or more additional activities to enable to callback */ public void setOnNdefPushCompleteCallback(OnNdefPushCompleteCallback callback, Activity activity, Activity ... activities) { if (activity == null) { throw new NullPointerException("activity cannot be null"); } mNfcActivityManager.setOnNdefPushCompleteCallback(activity, callback); for (Activity a : activities) { if (a == null) { throw new NullPointerException("activities cannot contain null"); } mNfcActivityManager.setOnNdefPushCompleteCallback(a, callback); } } /** * Enable foreground dispatch to the given Activity. * *
This will give give priority to the foreground activity when * dispatching a discovered {@link Tag} to an application. * *
If any IntentFilters are provided to this method they are used to match dispatch Intents * for both the {@link NfcAdapter#ACTION_NDEF_DISCOVERED} and * {@link NfcAdapter#ACTION_TAG_DISCOVERED}. Since {@link NfcAdapter#ACTION_TECH_DISCOVERED} * relies on meta data outside of the IntentFilter matching for that dispatch Intent is handled * by passing in the tech lists separately. Each first level entry in the tech list represents * an array of technologies that must all be present to match. If any of the first level sets * match then the dispatch is routed through the given PendingIntent. In other words, the second * level is ANDed together and the first level entries are ORed together. * *
If you pass {@code null} for both the {@code filters} and {@code techLists} parameters * that acts a wild card and will cause the foreground activity to receive all tags via the * {@link NfcAdapter#ACTION_TAG_DISCOVERED} intent. * *
This method must be called from the main thread, and only when the activity is in the * foreground (resumed). Also, activities must call {@link #disableForegroundDispatch} before * the completion of their {@link Activity#onPause} callback to disable foreground dispatch * after it has been enabled. * *
Requires the {@link android.Manifest.permission#NFC} permission. * * @param activity the Activity to dispatch to * @param intent the PendingIntent to start for the dispatch * @param filters the IntentFilters to override dispatching for, or null to always dispatch * @param techLists the tech lists used to perform matching for dispatching of the * {@link NfcAdapter#ACTION_TECH_DISCOVERED} intent * @throws IllegalStateException if the Activity is not currently in the foreground */ public void enableForegroundDispatch(Activity activity, PendingIntent intent, IntentFilter[] filters, String[][] techLists) { if (activity == null || intent == null) { throw new NullPointerException(); } if (!activity.isResumed()) { throw new IllegalStateException("Foreground dispatch can only be enabled " + "when your activity is resumed"); } try { TechListParcel parcel = null; if (techLists != null && techLists.length > 0) { parcel = new TechListParcel(techLists); } ActivityThread.currentActivityThread().registerOnActivityPausedListener(activity, mForegroundDispatchListener); sService.setForegroundDispatch(intent, filters, parcel); } catch (RemoteException e) { attemptDeadServiceRecovery(e); } } /** * Disable foreground dispatch to the given activity. * *
After calling {@link #enableForegroundDispatch}, an activity * must call this method before its {@link Activity#onPause} callback * completes. * *
This method must be called from the main thread. * *
Requires the {@link android.Manifest.permission#NFC} permission. * * @param activity the Activity to disable dispatch to * @throws IllegalStateException if the Activity has already been paused */ public void disableForegroundDispatch(Activity activity) { ActivityThread.currentActivityThread().unregisterOnActivityPausedListener(activity, mForegroundDispatchListener); disableForegroundDispatchInternal(activity, false); } OnActivityPausedListener mForegroundDispatchListener = new OnActivityPausedListener() { @Override public void onPaused(Activity activity) { disableForegroundDispatchInternal(activity, true); } }; void disableForegroundDispatchInternal(Activity activity, boolean force) { try { sService.setForegroundDispatch(null, null, null); if (!force && !activity.isResumed()) { throw new IllegalStateException("You must disable foreground dispatching " + "while your activity is still resumed"); } } catch (RemoteException e) { attemptDeadServiceRecovery(e); } } /** * Enable NDEF message push over NFC while this Activity is in the foreground. * *
You must explicitly call this method every time the activity is * resumed, and you must call {@link #disableForegroundNdefPush} before * your activity completes {@link Activity#onPause}. * *
Strongly recommend to use the new {@link #setNdefPushMessage} * instead: it automatically hooks into your activity life-cycle, * so you do not need to call enable/disable in your onResume/onPause. * *
For NDEF push to function properly the other NFC device must * support either NFC Forum's SNEP (Simple Ndef Exchange Protocol), or * Android's "com.android.npp" (Ndef Push Protocol). This was optional * on Gingerbread level Android NFC devices, but SNEP is mandatory on * Ice-Cream-Sandwich and beyond. * *
This method must be called from the main thread. * *
Requires the {@link android.Manifest.permission#NFC} permission. * * @param activity foreground activity * @param message a NDEF Message to push over NFC * @throws IllegalStateException if the activity is not currently in the foreground * @deprecated use {@link #setNdefPushMessage} instead */ @Deprecated public void enableForegroundNdefPush(Activity activity, NdefMessage message) { if (activity == null || message == null) { throw new NullPointerException(); } enforceResumed(activity); mNfcActivityManager.setNdefPushMessage(activity, message); } /** * Disable NDEF message push over P2P. * *
After calling {@link #enableForegroundNdefPush}, an activity * must call this method before its {@link Activity#onPause} callback * completes. * *
Strongly recommend to use the new {@link #setNdefPushMessage} * instead: it automatically hooks into your activity life-cycle, * so you do not need to call enable/disable in your onResume/onPause. * *
This method must be called from the main thread. * *
Requires the {@link android.Manifest.permission#NFC} permission. * * @param activity the Foreground activity * @throws IllegalStateException if the Activity has already been paused * @deprecated use {@link #setNdefPushMessage} instead */ public void disableForegroundNdefPush(Activity activity) { if (activity == null) { throw new NullPointerException(); } enforceResumed(activity); mNfcActivityManager.setNdefPushMessage(activity, null); mNfcActivityManager.setNdefPushMessageCallback(activity, null); mNfcActivityManager.setOnNdefPushCompleteCallback(activity, null); } /** * TODO: Remove this once pre-built apk's (Maps, Youtube etc) are updated * @deprecated use {@link CreateNdefMessageCallback} or {@link OnNdefPushCompleteCallback} * @hide */ @Deprecated public interface NdefPushCallback { /** * @deprecated use {@link CreateNdefMessageCallback} instead */ @Deprecated NdefMessage createMessage(); /** * @deprecated use{@link OnNdefPushCompleteCallback} instead */ @Deprecated void onMessagePushed(); } /** * TODO: Remove this * Converts new callbacks to old callbacks. */ static final class LegacyCallbackWrapper implements CreateNdefMessageCallback, OnNdefPushCompleteCallback { final NdefPushCallback mLegacyCallback; LegacyCallbackWrapper(NdefPushCallback legacyCallback) { mLegacyCallback = legacyCallback; } @Override public void onNdefPushComplete(NfcEvent event) { mLegacyCallback.onMessagePushed(); } @Override public NdefMessage createNdefMessage(NfcEvent event) { return mLegacyCallback.createMessage(); } } /** * TODO: Remove this once pre-built apk's (Maps, Youtube etc) are updated * @deprecated use {@link #setNdefPushMessageCallback} instead * @hide */ @Deprecated public void enableForegroundNdefPush(Activity activity, final NdefPushCallback callback) { if (activity == null || callback == null) { throw new NullPointerException(); } enforceResumed(activity); LegacyCallbackWrapper callbackWrapper = new LegacyCallbackWrapper(callback); mNfcActivityManager.setNdefPushMessageCallback(activity, callbackWrapper); mNfcActivityManager.setOnNdefPushCompleteCallback(activity, callbackWrapper); } /** * Enable NDEF Push feature. *
This API is for the Settings application. * @hide */ public boolean enableNdefPush() { try { return sService.enableNdefPush(); } catch (RemoteException e) { attemptDeadServiceRecovery(e); return false; } } /** * Disable NDEF Push feature. *
This API is for the Settings application. * @hide */ public boolean disableNdefPush() { try { return sService.disableNdefPush(); } catch (RemoteException e) { attemptDeadServiceRecovery(e); return false; } } /** * Return true if NDEF Push feature is enabled. *
This function can return true even if NFC is currently turned-off. * This indicates that NDEF Push is not currently active, but it has * been requested by the user and will be active as soon as NFC is turned * on. *
If you want to check if NDEF PUsh sharing is currently active, use
* {@link #isEnabled()} && {@link #isNdefPushEnabled()}
*
* @return true if NDEF Push feature is enabled
* @hide
*/
public boolean isNdefPushEnabled() {
try {
return sService.isNdefPushEnabled();
} catch (RemoteException e) {
attemptDeadServiceRecovery(e);
return false;
}
}
/**
* @hide
*/
public INfcAdapterExtras getNfcAdapterExtrasInterface() {
try {
return sService.getNfcAdapterExtrasInterface();
} catch (RemoteException e) {
attemptDeadServiceRecovery(e);
return null;
}
}
void enforceResumed(Activity activity) {
if (!activity.isResumed()) {
throw new IllegalStateException("API cannot be called while activity is paused");
}
}
}