Use of this class requires the * {@link PackageManager#FEATURE_NFC_HOST_CARD_EMULATION} to be present * on the device. */ public final class CardEmulation { private static final Pattern AID_PATTERN = Pattern.compile("[0-9A-Fa-f]{10,32}\\*?\\#?"); private static final Pattern PLPF_PATTERN = Pattern.compile("[0-9A-Fa-f,\\?,\\*\\.]*"); static final String TAG = "CardEmulation"; /** * Activity action: ask the user to change the default * card emulation service for a certain category. This will * show a dialog that asks the user whether they want to * replace the current default service with the service * identified with the ComponentName specified in * {@link #EXTRA_SERVICE_COMPONENT}, for the category * specified in {@link #EXTRA_CATEGORY}. There is an optional * extra field using {@link Intent#EXTRA_USER} to specify * the {@link UserHandle} of the user that owns the app. * * @deprecated Please use {@link android.app.role.RoleManager#createRequestRoleIntent(String)} * with {@link android.app.role.RoleManager#ROLE_WALLET} parameter * and {@link Activity#startActivityForResult(Intent, int)} instead. */ @Deprecated @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) public static final String ACTION_CHANGE_DEFAULT = "android.nfc.cardemulation.action.ACTION_CHANGE_DEFAULT"; /** * The category extra for {@link #ACTION_CHANGE_DEFAULT}. * * @see #ACTION_CHANGE_DEFAULT */ public static final String EXTRA_CATEGORY = "category"; /** * The service {@link ComponentName} object passed in as an * extra for {@link #ACTION_CHANGE_DEFAULT}. * * @see #ACTION_CHANGE_DEFAULT */ public static final String EXTRA_SERVICE_COMPONENT = "component"; /** * Category used for NFC payment services. */ public static final String CATEGORY_PAYMENT = "payment"; /** * Category that can be used for all other card emulation * services. */ public static final String CATEGORY_OTHER = "other"; /** * Return value for {@link #getSelectionModeForCategory(String)}. * *
In this mode, the user has set a default service for this * category. * *
When using ISO-DEP card emulation with {@link HostApduService} * or {@link OffHostApduService}, if a remote NFC device selects * any of the Application IDs (AIDs) * that the default service has registered in this category, * that service will automatically be bound to to handle * the transaction. */ public static final int SELECTION_MODE_PREFER_DEFAULT = 0; /** * Return value for {@link #getSelectionModeForCategory(String)}. * *
In this mode, when using ISO-DEP card emulation with {@link HostApduService} * or {@link OffHostApduService}, whenever an Application ID (AID) of this category * is selected, the user is asked which service they want to use to handle * the transaction, even if there is only one matching service. */ public static final int SELECTION_MODE_ALWAYS_ASK = 1; /** * Return value for {@link #getSelectionModeForCategory(String)}. * *
In this mode, when using ISO-DEP card emulation with {@link HostApduService}
* or {@link OffHostApduService}, the user will only be asked to select a service
* if the Application ID (AID) selected by the reader has been registered by multiple
* services. If there is only one service that has registered for the AID,
* that service will be invoked directly.
*/
public static final int SELECTION_MODE_ASK_IF_CONFLICT = 2;
static boolean sIsInitialized = false;
static HashMap Note that if {@link #getSelectionModeForCategory(String)}
* returns {@link #SELECTION_MODE_ALWAYS_ASK} or {@link #SELECTION_MODE_ASK_IF_CONFLICT},
* this method will always return false. That is because in these
* selection modes a default can't be set at the category level. For categories where
* the selection mode is {@link #SELECTION_MODE_ALWAYS_ASK} or
* {@link #SELECTION_MODE_ASK_IF_CONFLICT}, use
* {@link #isDefaultServiceForAid(ComponentName, String)} to determine whether a service
* is the default for a specific AID.
*
* @param service The ComponentName of the service
* @param category The category
* @return whether service is currently the default service for the category.
*
* Requires the {@link android.Manifest.permission#NFC} permission.
*/
public boolean isDefaultServiceForCategory(ComponentName service, String category) {
try {
return sService.isDefaultServiceForCategory(mContext.getUser().getIdentifier(),
service, category);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.isDefaultServiceForCategory(mContext.getUser().getIdentifier(),
service, category);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
}
}
/**
*
* Allows an application to query whether a service is currently
* the default handler for a specified ISO7816-4 Application ID.
*
* @param service The ComponentName of the service
* @param aid The ISO7816-4 Application ID
* @return whether the service is the default handler for the specified AID
*
* Requires the {@link android.Manifest.permission#NFC} permission.
*/
public boolean isDefaultServiceForAid(ComponentName service, String aid) {
try {
return sService.isDefaultServiceForAid(mContext.getUser().getIdentifier(),
service, aid);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.isDefaultServiceForAid(mContext.getUser().getIdentifier(),
service, aid);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
*
* Returns whether the user has allowed AIDs registered in the
* specified category to be handled by a service that is preferred
* by the foreground application, instead of by a pre-configured default.
*
* Foreground applications can set such preferences using the
* {@link #setPreferredService(Activity, ComponentName)} method.
*
* Starting with {@link Build.VERSION_CODES#VANILLA_ICE_CREAM}, this method will always
* return true.
*
* @param category The category, e.g. {@link #CATEGORY_PAYMENT}
* @return whether AIDs in the category can be handled by a service
* specified by the foreground app.
*/
@SuppressWarnings("NonUserGetterCalled")
public boolean categoryAllowsForegroundPreference(String category) {
Context contextAsUser = mContext.createContextAsUser(
UserHandle.of(UserHandle.myUserId()), 0);
RoleManager roleManager = contextAsUser.getSystemService(RoleManager.class);
if (roleManager.isRoleAvailable(RoleManager.ROLE_WALLET)) {
return true;
}
if (CATEGORY_PAYMENT.equals(category)) {
boolean preferForeground = false;
try {
preferForeground = Settings.Secure.getInt(
contextAsUser.getContentResolver(),
Constants.SETTINGS_SECURE_NFC_PAYMENT_FOREGROUND) != 0;
} catch (SettingNotFoundException e) {
}
return preferForeground;
} else {
// Allowed for all other categories
return true;
}
}
/**
* Returns the service selection mode for the passed in category.
* Valid return values are:
* {@link #SELECTION_MODE_PREFER_DEFAULT} the user has requested a default
* service for this category, which will be preferred.
* {@link #SELECTION_MODE_ALWAYS_ASK} the user has requested to be asked
* every time what service they would like to use in this category.
* {@link #SELECTION_MODE_ASK_IF_CONFLICT} the user will only be asked
* to pick a service if there is a conflict.
*
*
* Starting with {@link Build.VERSION_CODES#VANILLA_ICE_CREAM}, the default service defined
* by the holder of {@link android.app.role.RoleManager#ROLE_WALLET} and is category agnostic.
*
* @param category The category, for example {@link #CATEGORY_PAYMENT}
* @return the selection mode for the passed in category
*/
public int getSelectionModeForCategory(String category) {
if (CATEGORY_PAYMENT.equals(category)) {
boolean paymentRegistered = false;
try {
paymentRegistered = sService.isDefaultPaymentRegistered();
} catch (RemoteException e) {
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return SELECTION_MODE_ALWAYS_ASK;
}
try {
paymentRegistered = sService.isDefaultPaymentRegistered();
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return SELECTION_MODE_ALWAYS_ASK;
}
}
if (paymentRegistered) {
return SELECTION_MODE_PREFER_DEFAULT;
} else {
return SELECTION_MODE_ALWAYS_ASK;
}
} else {
return SELECTION_MODE_ASK_IF_CONFLICT;
}
}
/**
* Sets whether when this service becomes the preferred service, if the NFC stack
* should enable observe mode or disable observe mode. The default is to not enable observe
* mode when a service either the foreground default service or the default payment service so
* not calling this method will preserve that behavior.
*
* @param service The component name of the service
* @param enable Whether the service should default to observe mode or not
* @return whether the change was successful.
*/
@FlaggedApi(Flags.FLAG_NFC_OBSERVE_MODE)
public boolean setShouldDefaultToObserveModeForService(@NonNull ComponentName service,
boolean enable) {
try {
return sService.setShouldDefaultToObserveModeForService(
mContext.getUser().getIdentifier(), service, enable);
} catch (RemoteException e) {
Log.e(TAG, "Failed to reach CardEmulationService.");
}
return false;
}
/**
* Register a polling loop filter (PLF) for a HostApduService and indicate whether it should
* auto-transact or not. The PLF can be sequence of an
* even number of at least 2 hexadecimal numbers (0-9, A-F or a-f), representing a series of
* bytes. When non-standard polling loop frame matches this sequence exactly, it may be
* delivered to {@link HostApduService#processPollingFrames(List)}. If auto-transact
* is set to true and this service is currently preferred or there are no other services
* registered for this filter then observe mode will also be disabled.
* @param service The HostApduService to register the filter for
* @param pollingLoopFilter The filter to register
* @param autoTransact true to have the NFC stack automatically disable observe mode and allow
* transactions to proceed when this filter matches, false otherwise
* @return true if the filter was registered, false otherwise
* @throws IllegalArgumentException if the passed in string doesn't parse to at least one byte
*/
@FlaggedApi(Flags.FLAG_NFC_READ_POLLING_LOOP)
public boolean registerPollingLoopFilterForService(@NonNull ComponentName service,
@NonNull String pollingLoopFilter, boolean autoTransact) {
pollingLoopFilter = validatePollingLoopFilter(pollingLoopFilter);
try {
return sService.registerPollingLoopFilterForService(mContext.getUser().getIdentifier(),
service, pollingLoopFilter, autoTransact);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.registerPollingLoopFilterForService(
mContext.getUser().getIdentifier(), service,
pollingLoopFilter, autoTransact);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* Unregister a polling loop filter (PLF) for a HostApduService. If the PLF had previously been
* registered via {@link #registerPollingLoopFilterForService(ComponentName, String, boolean)}
* for this service it will be removed.
* @param service The HostApduService to unregister the filter for
* @param pollingLoopFilter The filter to unregister
* @return true if the filter was removed, false otherwise
* @throws IllegalArgumentException if the passed in string doesn't parse to at least one byte
*/
@FlaggedApi(Flags.FLAG_NFC_READ_POLLING_LOOP)
public boolean removePollingLoopFilterForService(@NonNull ComponentName service,
@NonNull String pollingLoopFilter) {
pollingLoopFilter = validatePollingLoopFilter(pollingLoopFilter);
try {
return sService.removePollingLoopFilterForService(mContext.getUser().getIdentifier(),
service, pollingLoopFilter);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.removePollingLoopFilterForService(
mContext.getUser().getIdentifier(), service,
pollingLoopFilter);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* Register a polling loop pattern filter (PLPF) for a HostApduService and indicate whether it
* should auto-transact or not. The pattern may include the characters 0-9 and A-F as well as
* the regular expression operators `.`, `?` and `*`. When the beginning of anon-standard
* polling loop frame matches this sequence exactly, it may be delivered to
* {@link HostApduService#processPollingFrames(List)}. If auto-transact is set to true and this
* service is currently preferred or there are no other services registered for this filter
* then observe mode will also be disabled.
* @param service The HostApduService to register the filter for
* @param pollingLoopPatternFilter The pattern filter to register, must to be compatible with
* {@link java.util.regex.Pattern#compile(String)} and only contain hexadecimal numbers
* and `.`, `?` and `*` operators
* @param autoTransact true to have the NFC stack automatically disable observe mode and allow
* transactions to proceed when this filter matches, false otherwise
* @return true if the filter was registered, false otherwise
* @throws IllegalArgumentException if the filter containst elements other than hexadecimal
* numbers and `.`, `?` and `*` operators
* @throws java.util.regex.PatternSyntaxException if the regex syntax is invalid
*/
@FlaggedApi(Flags.FLAG_NFC_READ_POLLING_LOOP)
public boolean registerPollingLoopPatternFilterForService(@NonNull ComponentName service,
@NonNull String pollingLoopPatternFilter, boolean autoTransact) {
pollingLoopPatternFilter = validatePollingLoopPatternFilter(pollingLoopPatternFilter);
try {
return sService.registerPollingLoopPatternFilterForService(
mContext.getUser().getIdentifier(),
service, pollingLoopPatternFilter, autoTransact);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.registerPollingLoopPatternFilterForService(
mContext.getUser().getIdentifier(), service,
pollingLoopPatternFilter, autoTransact);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* Unregister a polling loop pattern filter (PLPF) for a HostApduService. If the PLF had
* previously been registered via
* {@link #registerPollingLoopFilterForService(ComponentName, String, boolean)} for this
* service it will be removed.
* @param service The HostApduService to unregister the filter for
* @param pollingLoopPatternFilter The filter to unregister, must to be compatible with
* {@link java.util.regex.Pattern#compile(String)} and only contain hexadecimal numbers
* and`.`, `?` and `*` operators
* @return true if the filter was removed, false otherwise
* @throws IllegalArgumentException if the filter containst elements other than hexadecimal
* numbers and `.`, `?` and `*` operators
* @throws java.util.regex.PatternSyntaxException if the regex syntax is invalid
*/
@FlaggedApi(Flags.FLAG_NFC_READ_POLLING_LOOP)
public boolean removePollingLoopPatternFilterForService(@NonNull ComponentName service,
@NonNull String pollingLoopPatternFilter) {
pollingLoopPatternFilter = validatePollingLoopPatternFilter(pollingLoopPatternFilter);
try {
return sService.removePollingLoopPatternFilterForService(
mContext.getUser().getIdentifier(), service, pollingLoopPatternFilter);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.removePollingLoopPatternFilterForService(
mContext.getUser().getIdentifier(), service,
pollingLoopPatternFilter);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* Registers a list of AIDs for a specific category for the
* specified service.
*
* If a list of AIDs for that category was previously
* registered for this service (either statically
* through the manifest, or dynamically by using this API),
* that list of AIDs will be replaced with this one.
*
* Note that you can only register AIDs for a service that
* is running under the same UID as the caller of this API. Typically
* this means you need to call this from the same
* package as the service itself, though UIDs can also
* be shared between packages using shared UIDs.
*
* @param service The component name of the service
* @param category The category of AIDs to be registered
* @param aids A list containing the AIDs to be registered
* @return whether the registration was successful.
*/
public boolean registerAidsForService(ComponentName service, String category,
List Note that this will only remove Secure Element that was dynamically
* set using the {@link #setOffHostForService(ComponentName, String)}
* and resets it to a value that was statically assigned using manifest.
*
* Note that you can only unset off-host SE for a service that
* is running under the same UID as the caller of this API. Typically
* this means you need to call this from the same
* package as the service itself, though UIDs can also
* be shared between packages using shared UIDs.
*
* @param service The component name of the service
* @return whether the registration was successful.
*/
@RequiresPermission(android.Manifest.permission.NFC)
@NonNull
public boolean unsetOffHostForService(@NonNull ComponentName service) {
NfcAdapter adapter = NfcAdapter.getDefaultAdapter(mContext);
if (adapter == null) {
return false;
}
try {
return sService.unsetOffHostForService(mContext.getUser().getIdentifier(), service);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.unsetOffHostForService(mContext.getUser().getIdentifier(), service);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* Sets the off-host Secure Element for the given service.
*
* If off-host SE was initially set (either statically
* through the manifest, or dynamically by using this API),
* it will be replaced with this one. All AIDs registered by
* this service will be re-routed to this Secure Element if
* successful. AIDs that was statically assigned using manifest
* will re-route to off-host SE that stated in manifest after NFC
* toggle.
*
* Note that you can only set off-host SE for a service that
* is running under the same UID as the caller of this API. Typically
* this means you need to call this from the same
* package as the service itself, though UIDs can also
* be shared between packages using shared UIDs.
*
* Registeration will be successful only if the Secure Element
* exists on the device.
*
* @param service The component name of the service
* @param offHostSecureElement Secure Element to register the AID to. Only accept strings with
* prefix SIM or prefix eSE.
* Ref: GSMA TS.26 - NFC Handset Requirements
* TS26_NFC_REQ_069: For UICC, Secure Element Name SHALL be
* SIM[smartcard slot]
* (e.g. SIM/SIM1, SIM2… SIMn).
* TS26_NFC_REQ_070: For embedded SE, Secure Element Name SHALL be
* eSE[number]
* (e.g. eSE/eSE1, eSE2, etc.).
* @return whether the registration was successful.
*/
@RequiresPermission(android.Manifest.permission.NFC)
@NonNull
public boolean setOffHostForService(@NonNull ComponentName service,
@NonNull String offHostSecureElement) {
boolean validSecureElement = false;
NfcAdapter adapter = NfcAdapter.getDefaultAdapter(mContext);
if (adapter == null || offHostSecureElement == null) {
return false;
}
List Note that this will only return AIDs that were dynamically
* registered using {@link #registerAidsForService(ComponentName, String, List)}
* method. It will *not* return AIDs that were statically registered
* in the manifest.
*
* @param service The component name of the service
* @param category The category for which the AIDs were registered,
* e.g. {@link #CATEGORY_PAYMENT}
* @return The list of AIDs registered for this category, or null if it couldn't be found.
*/
public List Note that this will only remove AIDs that were dynamically
* registered using the {@link #registerAidsForService(ComponentName, String, List)}
* method. It will *not* remove AIDs that were statically registered in
* the manifest. If dynamically registered AIDs are removed using
* this method, and a statically registered AID group for the same category
* exists in the manifest, the static AID group will become active again.
*
* @param service The component name of the service
* @param category The category of the AIDs to be removed, e.g. {@link #CATEGORY_PAYMENT}
* @return whether the group was successfully removed.
*/
public boolean removeAidsForService(ComponentName service, String category) {
try {
return sService.removeAidGroupForService(mContext.getUser().getIdentifier(), service,
category);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.removeAidGroupForService(mContext.getUser().getIdentifier(),
service, category);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* Allows a foreground application to specify which card emulation service
* should be preferred while a specific Activity is in the foreground.
*
* The specified Activity must currently be in resumed state. A good
* paradigm is to call this method in your {@link Activity#onResume}, and to call
* {@link #unsetPreferredService(Activity)} in your {@link Activity#onPause}.
*
* This method call will fail in two specific scenarios:
* Use {@link #categoryAllowsForegroundPreference(String)} to determine
* whether foreground apps can override the default payment service.
*
* Note that this preference is not persisted by the OS, and hence must be
* called every time the Activity is resumed.
*
* @param activity The activity which prefers this service to be invoked
* @param service The service to be preferred while this activity is in the foreground
* @return whether the registration was successful
*/
public boolean setPreferredService(Activity activity, ComponentName service) {
// Verify the activity is in the foreground before calling into NfcService
if (activity == null || service == null) {
throw new NullPointerException("activity or service or category is null");
}
try {
return sService.setPreferredService(service);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.setPreferredService(service);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* Unsets the preferred service for the specified Activity.
*
* Note that the specified Activity must still be in resumed
* state at the time of this call. A good place to call this method
* is in your {@link Activity#onPause} implementation.
*
* @param activity The activity which the service was registered for
* @return true when successful
*/
public boolean unsetPreferredService(Activity activity) {
if (activity == null) {
throw new NullPointerException("activity is null");
}
try {
return sService.unsetPreferredService();
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.unsetPreferredService();
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* Some devices may allow an application to register all
* AIDs that starts with a certain prefix, e.g.
* "A000000004*" to register all MasterCard AIDs.
*
* Use this method to determine whether this device
* supports registering AID prefixes.
*
* @return whether AID prefix registering is supported on this device.
*/
public boolean supportsAidPrefixRegistration() {
try {
return sService.supportsAidPrefixRegistration();
} catch (RemoteException e) {
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.supportsAidPrefixRegistration();
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* Retrieves the registered AIDs for the preferred payment service.
*
* @return The list of AIDs registered for this category, or null if it couldn't be found.
*/
@RequiresPermission(android.Manifest.permission.NFC_PREFERRED_PAYMENT_INFO)
@Nullable
public List
* Starting with {@link Build.VERSION_CODES#VANILLA_ICE_CREAM}, the preferred payment service
* no longer exists and is replaced by {@link android.app.role.RoleManager#ROLE_WALLET}. This
* will return the route for one of the services registered by the role holder (if any). If
* there are multiple services registered, it is unspecified which of those will be used to
* determine the route.
*
* @return The route destination secure element name of the preferred payment service.
* HCE payment: "Host"
* OffHost payment: 1. String with prefix SIM or prefix eSE string.
* Ref: GSMA TS.26 - NFC Handset Requirements
* TS26_NFC_REQ_069: For UICC, Secure Element Name SHALL be
* SIM[smartcard slot]
* (e.g. SIM/SIM1, SIM2… SIMn).
* TS26_NFC_REQ_070: For embedded SE, Secure Element Name SHALL be
* eSE[number]
* (e.g. eSE/eSE1, eSE2, etc.).
* 2. "OffHost" if the payment service does not specify secure element
* name.
*/
@RequiresPermission(android.Manifest.permission.NFC_PREFERRED_PAYMENT_INFO)
@Nullable
public String getRouteDestinationForPreferredPaymentService() {
try {
ApduServiceInfo serviceInfo = sService.getPreferredPaymentService(
mContext.getUser().getIdentifier());
if (serviceInfo != null) {
if (!serviceInfo.isOnHost()) {
return serviceInfo.getOffHostSecureElement() == null ?
"OffHost" : serviceInfo.getOffHostSecureElement();
}
return "Host";
}
return null;
} catch (RemoteException e) {
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
throw e.rethrowFromSystemServer();
}
try {
ApduServiceInfo serviceInfo =
sService.getPreferredPaymentService(mContext.getUser().getIdentifier());
if (serviceInfo != null) {
if (!serviceInfo.isOnHost()) {
return serviceInfo.getOffHostSecureElement() == null ?
"Offhost" : serviceInfo.getOffHostSecureElement();
}
return "Host";
}
return null;
} catch (RemoteException ee) {
Log.e(TAG, "Failed to recover CardEmulationService.");
throw e.rethrowFromSystemServer();
}
}
}
/**
* Returns a user-visible description of the preferred payment service.
*
*
* Starting with {@link Build.VERSION_CODES#VANILLA_ICE_CREAM}, the preferred payment service
* no longer exists and is replaced by {@link android.app.role.RoleManager#ROLE_WALLET}. This
* will return the description for one of the services registered by the role holder (if any).
* If there are multiple services registered, it is unspecified which of those will be used
* to obtain the service description here.
*
* @return the preferred payment service description
*/
@RequiresPermission(android.Manifest.permission.NFC_PREFERRED_PAYMENT_INFO)
@Nullable
public CharSequence getDescriptionForPreferredPaymentService() {
try {
ApduServiceInfo serviceInfo = sService.getPreferredPaymentService(
mContext.getUser().getIdentifier());
return (serviceInfo != null ? serviceInfo.getDescription() : null);
} catch (RemoteException e) {
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
throw e.rethrowFromSystemServer();
}
try {
ApduServiceInfo serviceInfo =
sService.getPreferredPaymentService(mContext.getUser().getIdentifier());
return (serviceInfo != null ? serviceInfo.getDescription() : null);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to recover CardEmulationService.");
throw e.rethrowFromSystemServer();
}
}
}
/**
* @hide
*/
public boolean setDefaultServiceForCategory(ComponentName service, String category) {
try {
return sService.setDefaultServiceForCategory(mContext.getUser().getIdentifier(),
service, category);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.setDefaultServiceForCategory(mContext.getUser().getIdentifier(),
service, category);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* @hide
*/
public boolean setDefaultForNextTap(ComponentName service) {
try {
return sService.setDefaultForNextTap(mContext.getUser().getIdentifier(), service);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.setDefaultForNextTap(mContext.getUser().getIdentifier(), service);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* @hide
*/
public boolean setDefaultForNextTap(int userId, ComponentName service) {
try {
return sService.setDefaultForNextTap(userId, service);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.setDefaultForNextTap(userId, service);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* @hide
*/
public List
* Example usage in an Activity that requires to set proto route to "ESE" and keep tech route:
*
*
*
*
*
*
* @hide
*/
public static boolean isValidAid(String aid) {
if (aid == null)
return false;
// If a prefix/subset AID, the total length must be odd (even # of AID chars + '*')
if ((aid.endsWith("*") || aid.endsWith("#")) && ((aid.length() % 2) == 0)) {
Log.e(TAG, "AID " + aid + " is not a valid AID.");
return false;
}
// If not a prefix/subset AID, the total length must be even (even # of AID chars)
if ((!(aid.endsWith("*") || aid.endsWith("#"))) && ((aid.length() % 2) != 0)) {
Log.e(TAG, "AID " + aid + " is not a valid AID.");
return false;
}
// Verify hex characters
if (!AID_PATTERN.matcher(aid).matches()) {
Log.e(TAG, "AID " + aid + " is not a valid AID.");
return false;
}
return true;
}
/**
* Allows to set or unset preferred service (category other) to avoid AID Collision.
*
* @param service The ComponentName of the service
* @param status true to enable, false to disable
* @param userId the user handle of the user whose information is being requested.
* @return set service for the category and true if service is already set return false.
*
* @hide
*/
public boolean setServiceEnabledForCategoryOther(ComponentName service, boolean status,
int userId) {
if (service == null) {
throw new NullPointerException("activity or service or category is null");
}
try {
return sService.setServiceEnabledForCategoryOther(userId, service, status);
} catch (RemoteException e) {
// Try one more time
recoverService();
if (sService == null) {
Log.e(TAG, "Failed to recover CardEmulationService.");
return false;
}
try {
return sService.setServiceEnabledForCategoryOther(userId, service, status);
} catch (RemoteException ee) {
Log.e(TAG, "Failed to reach CardEmulationService.");
return false;
}
}
}
/**
* Setting NFC controller routing table, which includes Protocol Route and Technology Route,
* while this Activity is in the foreground.
*
* The parameter set to null can be used to keep current values for that entry.
*
* protected void onResume() {
* mNfcAdapter.overrideRoutingTable(this , "ESE" , null);
* }
*