Blame - src/com/android/nfc/NfcService.java - platform/vendor/nxp/opensource/packages/apps/Nfc

2016-08-01 19:11:04 +0530

[diff] [blame]

2445

if(routeLoc == 0x00)

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

2446

{

nxpandroid

2016-09-16 20:21:47 +0530

[diff] [blame]

2447

/*

2448

bit pos 1 = Power Off

2449

bit pos 2 = Battery Off

2450

bit pos 4 = Screen Off

2451

Set these bits to 0 because in case routeLoc = HOST it can not work on POWER_OFF, BATTERY_OFF and SCREEN_OFF*/

2452

protoRouteEntry &= 0xE9;

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

2453

}

nxpandroid

2016-09-16 20:21:47 +0530

[diff] [blame]

2454

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

2455

Log.i(TAG,"MifareDesfireRouteSet : " + protoRouteEntry);

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

2456

mNxpPrefsEditor = mNxpPrefs.edit();

2457

mNxpPrefsEditor.putInt("PREF_MIFARE_DESFIRE_PROTO_ROUTE_ID", protoRouteEntry);

2458

mNxpPrefsEditor.commit();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

2459

Log.i(TAG,"MifareDesfireRouteSet function in");

commitRouting();

}

public void DefaultRouteSet(int routeLoc, boolean fullPower, boolean lowPower, boolean noPower)

2464

throws RemoteException

2465

{

anil.hiranniah

2018-02-07 19:29:55 +0530

[diff] [blame]

2466

if((mChipVer < PN553_ID) && (routeLoc == UICC2_ID_TYPE)) {

2467

throw new RemoteException("UICC2 is not supported");

2468

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

2469

if (mIsHceCapable) {

2470

int protoRouteEntry = 0;

anil.hiranniah

2018-02-07 19:29:55 +0530

[diff] [blame]

2471

protoRouteEntry=((routeLoc & 0x07) == 0x04) ? (0x03 << ROUTE_LOC_MASK) : /*UICC2*/

2472

((routeLoc & 0x07) == 0x02) ? (0x02 << ROUTE_LOC_MASK) : /*UICC1*/

2473

((routeLoc & 0x07) == 0x01) ? (0x01 << ROUTE_LOC_MASK) : /*eSE*/

2474

0x00;

nxpandroid

2016-09-16 20:21:47 +0530

[diff] [blame]

2475

protoRouteEntry |= ((fullPower ? (mDeviceHost.getDefaultAidPowerState() & 0x1F) | 0x01 : 0) | (lowPower ? 0x01 << 1 :0 ) | (noPower ? 0x01 << 2 :0));

2476

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

2477

if(routeLoc == 0x00)

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

2478

{

nxpandroid

2016-09-16 20:21:47 +0530

[diff] [blame]

2479

/*

2480

bit pos 1 = Power Off

2481

bit pos 2 = Battery Off

2482

bit pos 4 = Screen Off

2483

Set these bits to 0 because in case routeLoc = HOST it can not work on POWER_OFF, BATTERY_OFF and SCREEN_OFF*/

2484

protoRouteEntry &= 0xE9;

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

2485

}

2486

Log.i(TAG,"DefaultRouteSet : " + protoRouteEntry);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

2487

if(GetDefaultRouteLoc() != routeLoc)

2488

{

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

2489

mNxpPrefsEditor = mNxpPrefs.edit();

2490

mNxpPrefsEditor.putInt("PREF_SET_DEFAULT_ROUTE_ID", protoRouteEntry );

2491

mNxpPrefsEditor.commit();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

2492

mIsRouteForced = true;

2493

if (mIsHceCapable) {

2494

mAidRoutingManager.onNfccRoutingTableCleared();

2495

mCardEmulationManager.onRoutingTableChanged();

2496

}

2497

mIsRouteForced = false;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

}

else{

Log.i(TAG,"DefaultRoute can not be set. mIsHceCapable = flase");

}

}

public void MifareCLTRouteSet(int routeLoc, boolean fullPower, boolean lowPower, boolean noPower)

2506

throws RemoteException

2507

{

anil.hiranniah

2018-02-07 19:29:55 +0530

[diff] [blame]

2508

if((mChipVer < PN553_ID) && (routeLoc == UICC2_ID_TYPE)) {

2509

throw new RemoteException("UICC2 is not supported");

2510

}

2511

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

2512

int techRouteEntry=0;

anil.hiranniah

2018-02-07 19:29:55 +0530

[diff] [blame]

2513

techRouteEntry=((routeLoc & 0x07) == 0x04) ? (0x03 << ROUTE_LOC_MASK) : /*UICC2*/

2514

((routeLoc & 0x07) == 0x02) ? (0x02 << ROUTE_LOC_MASK) : /*UICC1*/

2515

((routeLoc & 0x07) == 0x01) ? (0x01 << ROUTE_LOC_MASK) : /*eSE*/

2516

0x00;

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

2517

techRouteEntry |= ((fullPower ? (mDeviceHost.getDefaultMifareCLTPowerState() & 0x1F) | 0x01 : 0) | (lowPower ? 0x01 << 1 :0 ) | (noPower ? 0x01 << 2 :0));

2518

techRouteEntry |= (TECH_TYPE_A << TECH_TYPE_MASK);

2519

2520

Log.i(TAG,"MifareCLTRouteSet : " + techRouteEntry);

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

2521

mNxpPrefsEditor = mNxpPrefs.edit();

2522

mNxpPrefsEditor.putInt("PREF_MIFARE_CLT_ROUTE_ID", techRouteEntry);

2523

mNxpPrefsEditor.commit();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

commitRouting();

}

@Override

public byte[] getFWVersion()

2528

{

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

2529

byte[] buf = new byte[3];

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

2530

Log.i(TAG, "Starting getFwVersion");

2531

int fwver = mDeviceHost.getFWVersion();

2532

buf[0] = (byte)((fwver&0xFF00)>>8);

2533

buf[1] = (byte)((fwver&0xFF));

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

2534

buf[2] = (byte)((fwver&0xFF0000)>>16);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

2535

Log.i(TAG, "Firmware version is 0x"+ buf[0]+" 0x"+buf[1]);

return buf;

}

@Override

public Map<String,Integer> getServicesAidCacheSize(int userId, String category){

2541

return mCardEmulationManager.getServicesAidCacheSize(userId, category);

2542

}

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

2543

2544

@Override

2545

public int updateServiceState(int userId , Map serviceState) {

2546

return mCardEmulationManager.updateServiceState(userId ,serviceState);

2547

}

2548

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

2549

@Override

2550

public int getSeInterface(int type) throws RemoteException {

2551

return mDeviceHost.doGetSeInterface(type);

2552

}

2553

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

2554

@Override

2555

public int getMaxAidRoutingTableSize() throws RemoteException {

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

2556

NfcPermissions.enforceUserPermissions(mContext);

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

2557

return getAidRoutingTableSize();

2558

}

2559

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

2560

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

2561

@Override

2562

public int getCommittedAidRoutingTableSize() throws RemoteException {

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

2563

NfcPermissions.enforceUserPermissions(mContext);

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

2564

return (getAidRoutingTableSize() - getRemainingAidTableSize());

2565

}

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

2566

2567

@Override

2568

public int setConfig(String configs , String pkg) {

2569

Log.e(TAG, "Setting configs for Transit" );

2570

/*Check permissions*/

2571

NfcPermissions.enforceAdminPermissions(mContext);

2572

/*Check if any NFC transactions are ongoing*/

2573

if(mDeviceHost.isNfccBusy())

2574

{

2575

Log.e(TAG, "NFCC is busy.." );

2576

return TRANSIT_SETCONFIG_STAT_FAILED;

2577

}

2578

/*check if format of configs is fine*/

2579

/*Save configurations to file*/

2580

try {

nxpandroid

f1f54f5

2017-07-31 16:08:06 +0530

[diff] [blame]

2581

File newTextFile = new File("/data/vendor/nfc/libnfc-nxpTransit.conf");

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

2582

if(configs == null)

2583

{

2584

if(newTextFile.delete()){

2585

Log.e(TAG, "Removing transit config file. Taking default Value" );

2586

}else{

2587

System.out.println("Error taking defualt value");

}

}

else

{

FileWriter fw = new FileWriter(newTextFile);

2593

fw.write(configs);

2594

fw.close();

2595

Log.e(TAG, "File Written to libnfc-nxpTransit.conf successfully" );

2596

}

2597

} catch (Exception e) {

2598

e.printStackTrace();

2599

return TRANSIT_SETCONFIG_STAT_FAILED;

2600

}

2601

2602

/*restart NFC service*/

2603

try {

2604

mNfcAdapter.disable(true);

2605

mNfcAdapter.enable();

2606

} catch (Exception e) {

2607

Log.e(TAG, "Unable to restart NFC Service");

2608

e.printStackTrace();

2609

return TRANSIT_SETCONFIG_STAT_FAILED;

2610

}

2611

return TRANSIT_SETCONFIG_STAT_SUCCESS;

2612

}

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

2613

2614

@Override

2615

public int mPOSSetReaderMode (String pkg, boolean on) {

2616

NfcService.this.enforceNfceeAdminPerm(pkg);

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

2617

// Check if NFC is enabled

2618

if (!isNfcEnabled()) {

2619

return NxpConstants.MPOS_STATUS_REJECTED;

2620

}

2621

2622

synchronized(NfcService.this) {

2623

int status = mDeviceHost.mposSetReaderMode(on);

2624

if(!on) {

2625

if(nci_version != NCI_VERSION_2_0) {

2626

applyRouting(true);

2627

} else if(mScreenState == ScreenStateHelper.SCREEN_STATE_ON_UNLOCKED

2628

|| mNfcUnlockManager.isLockscreenPollingEnabled()) {

2629

applyRouting(false);

2630

}

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

2631

}

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

return status;

}

}

@Override

public boolean mPOSGetReaderMode (String pkg) {

2638

NfcService.this.enforceNfceeAdminPerm(pkg);

2639

// Check if NFC is enabled

2640

if (!isNfcEnabled()) {

return false;

}

boolean status = false;

2645

synchronized(NfcService.this) {

2646

status = mDeviceHost.mposGetReaderMode();

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

}

return status;

}

@Override

public void stopPoll(String pkg, int mode) {

2653

NfcService.this.enforceNfceeAdminPerm(pkg);

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

2654

// Check if NFC is enabled

2655

if (!isNfcEnabled()) {

return;

}

synchronized(NfcService.this) {

2660

mDeviceHost.stopPoll(mode);

2661

}

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

}

@Override

public void startPoll(String pkg) {

2666

NfcService.this.enforceNfceeAdminPerm(pkg);

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

2667

// Check if NFC is enabled

2668

if (!isNfcEnabled()) {

return;

}

synchronized(NfcService.this) {

2673

mDeviceHost.startPoll();

2674

}

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

2675

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

2676

}

2677

2678

final class ReaderModeDeathRecipient implements IBinder.DeathRecipient {

2679

@Override

2680

public void binderDied() {

2681

synchronized (NfcService.this) {

2682

if (mReaderModeParams != null) {

2683

mReaderModeParams = null;

2684

Log.e(TAG, "applyRouting -5");

applyRouting(false);

}

}

}

}

final class TagService extends INfcTag.Stub {

2692

@Override

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

2693

public int connect(int nativeHandle, int technology) throws RemoteException {

2694

NfcPermissions.enforceUserPermissions(mContext);

2695

2696

TagEndpoint tag = null;

2697

2698

if (!isNfcEnabled()) {

2699

return ErrorCodes.ERROR_NOT_INITIALIZED;

2700

}

2701

2702

/* find the tag in the hmap */

2703

tag = (TagEndpoint) findObject(nativeHandle);

2704

if (tag == null) {

2705

return ErrorCodes.ERROR_DISCONNECT;

2706

}

2707

2708

if (!tag.isPresent()) {

2709

return ErrorCodes.ERROR_DISCONNECT;

2710

}

2711

2712

// Note that on most tags, all technologies are behind a single

2713

// handle. This means that the connect at the lower levels

2714

// will do nothing, as the tag is already connected to that handle.

2715

if (tag.connect(technology)) {

2716

return ErrorCodes.SUCCESS;

2717

} else {

2718

return ErrorCodes.ERROR_DISCONNECT;

}

}

@Override

public int reconnect(int nativeHandle) throws RemoteException {

2724

NfcPermissions.enforceUserPermissions(mContext);

2725

2726

TagEndpoint tag = null;

2727

2728

// Check if NFC is enabled

2729

if (!isNfcEnabled()) {

2730

return ErrorCodes.ERROR_NOT_INITIALIZED;

2731

}

2732

2733

/* find the tag in the hmap */

2734

tag = (TagEndpoint) findObject(nativeHandle);

2735

if (tag != null) {

2736

if (tag.reconnect()) {

2737

return ErrorCodes.SUCCESS;

2738

} else {

2739

return ErrorCodes.ERROR_DISCONNECT;

2740

}

2741

}

2742

return ErrorCodes.ERROR_DISCONNECT;

}

@Override

public int[] getTechList(int nativeHandle) throws RemoteException {

2747

NfcPermissions.enforceUserPermissions(mContext);

2748

2749

// Check if NFC is enabled

2750

if (!isNfcEnabled()) {

return null;

}

/* find the tag in the hmap */

2755

TagEndpoint tag = (TagEndpoint) findObject(nativeHandle);

2756

if (tag != null) {

2757

return tag.getTechList();

}

return null;

}

@Override

public boolean isPresent(int nativeHandle) throws RemoteException {

2764

TagEndpoint tag = null;

2765

2766

// Check if NFC is enabled

2767

if (!isNfcEnabled()) {

return false;

}

/* find the tag in the hmap */

2772

tag = (TagEndpoint) findObject(nativeHandle);

if (tag == null) {

return false;

}

return tag.isPresent();

}

@Override

public boolean isNdef(int nativeHandle) throws RemoteException {

2782

NfcPermissions.enforceUserPermissions(mContext);

2783

2784

TagEndpoint tag = null;

2785

2786

// Check if NFC is enabled

2787

if (!isNfcEnabled()) {

return false;

}

/* find the tag in the hmap */

2792

tag = (TagEndpoint) findObject(nativeHandle);

2793

int[] ndefInfo = new int[2];

if (tag == null) {

return false;

}

return tag.checkNdef(ndefInfo);

}

@Override

public TransceiveResult transceive(int nativeHandle, byte[] data, boolean raw)

2802

throws RemoteException {

2803

NfcPermissions.enforceUserPermissions(mContext);

2804

2805

TagEndpoint tag = null;

2806

byte[] response;

2807

2808

// Check if NFC is enabled

2809

if (!isNfcEnabled()) {

return null;

}

/* find the tag in the hmap */

2814

tag = (TagEndpoint) findObject(nativeHandle);

2815

if (tag != null) {

2816

// Check if length is within limits

2817

if (data.length > getMaxTransceiveLength(tag.getConnectedTechnology())) {

2818

return new TransceiveResult(TransceiveResult.RESULT_EXCEEDED_LENGTH, null);

2819

}

2820

int[] targetLost = new int[1];

2821

response = tag.transceive(data, raw, targetLost);

2822

int result;

2823

if (response != null) {

2824

result = TransceiveResult.RESULT_SUCCESS;

2825

} else if (targetLost[0] == 1) {

2826

result = TransceiveResult.RESULT_TAGLOST;

2827

} else {

2828

result = TransceiveResult.RESULT_FAILURE;

2829

}

2830

return new TransceiveResult(result, response);

}

return null;

}

@Override

public NdefMessage ndefRead(int nativeHandle) throws RemoteException {

2837

NfcPermissions.enforceUserPermissions(mContext);

TagEndpoint tag;

// Check if NFC is enabled

2842

if (!isNfcEnabled()) {

return null;

}

/* find the tag in the hmap */

2847

tag = (TagEndpoint) findObject(nativeHandle);

2848

if (tag != null) {

2849

byte[] buf = tag.readNdef();

if (buf == null) {

return null;

}

/* Create an NdefMessage */

2855

try {

2856

return new NdefMessage(buf);

2857

} catch (FormatException e) {

return null;

}

}

return null;

}

@Override

public int ndefWrite(int nativeHandle, NdefMessage msg) throws RemoteException {

2866

NfcPermissions.enforceUserPermissions(mContext);

TagEndpoint tag;

// Check if NFC is enabled

2871

if (!isNfcEnabled()) {

2872

return ErrorCodes.ERROR_NOT_INITIALIZED;

2873

}

2874

2875

/* find the tag in the hmap */

2876

tag = (TagEndpoint) findObject(nativeHandle);

2877

if (tag == null) {

2878

return ErrorCodes.ERROR_IO;

2879

}

2880

2881

if (msg == null) return ErrorCodes.ERROR_INVALID_PARAM;

2882

2883

if (tag.writeNdef(msg.toByteArray())) {

2884

return ErrorCodes.SUCCESS;

2885

} else {

2886

return ErrorCodes.ERROR_IO;

}

}

@Override

public boolean ndefIsWritable(int nativeHandle) throws RemoteException {

2893

throw new UnsupportedOperationException();

}

@Override

public int ndefMakeReadOnly(int nativeHandle) throws RemoteException {

2898

NfcPermissions.enforceUserPermissions(mContext);

TagEndpoint tag;

// Check if NFC is enabled

2903

if (!isNfcEnabled()) {

2904

return ErrorCodes.ERROR_NOT_INITIALIZED;

2905

}

2906

2907

/* find the tag in the hmap */

2908

tag = (TagEndpoint) findObject(nativeHandle);

2909

if (tag == null) {

2910

return ErrorCodes.ERROR_IO;

2911

}

2912

2913

if (tag.makeReadOnly()) {

2914

return ErrorCodes.SUCCESS;

2915

} else {

2916

return ErrorCodes.ERROR_IO;

}

}

@Override

public int formatNdef(int nativeHandle, byte[] key) throws RemoteException {

2922

NfcPermissions.enforceUserPermissions(mContext);

TagEndpoint tag;

// Check if NFC is enabled

2927

if (!isNfcEnabled()) {

2928

return ErrorCodes.ERROR_NOT_INITIALIZED;

2929

}

2930

2931

/* find the tag in the hmap */

2932

tag = (TagEndpoint) findObject(nativeHandle);

2933

if (tag == null) {

2934

return ErrorCodes.ERROR_IO;

2935

}

2936

2937

if (tag.formatNdef(key)) {

2938

return ErrorCodes.SUCCESS;

2939

} else {

2940

return ErrorCodes.ERROR_IO;

}

}

@Override

public Tag rediscover(int nativeHandle) throws RemoteException {

2946

NfcPermissions.enforceUserPermissions(mContext);

2947

2948

TagEndpoint tag = null;

2949

2950

// Check if NFC is enabled

2951

if (!isNfcEnabled()) {

return null;

}

/* find the tag in the hmap */

2956

tag = (TagEndpoint) findObject(nativeHandle);

2957

if (tag != null) {

2958

// For now the prime usecase for rediscover() is to be able

2959

// to access the NDEF technology after formatting without

2960

// having to remove the tag from the field, or similar

2961

// to have access to NdefFormatable in case low-level commands

2962

// were used to remove NDEF. So instead of doing a full stack

2963

// rediscover (which is poorly supported at the moment anyway),

2964

// we simply remove these two technologies and detect them

2965

// again.

2966

tag.removeTechnology(TagTechnology.NDEF);

2967

tag.removeTechnology(TagTechnology.NDEF_FORMATABLE);

2968

tag.findAndReadNdef();

2969

// Build a new Tag object to return

2970

Tag newTag = new Tag(tag.getUid(), tag.getTechList(),

2971

tag.getTechExtras(), tag.getHandle(), this);

return newTag;

}

return null;

}

@Override

public int setTimeout(int tech, int timeout) throws RemoteException {

2979

NfcPermissions.enforceUserPermissions(mContext);

2980

boolean success = mDeviceHost.setTimeout(tech, timeout);

2981

if (success) {

2982

return ErrorCodes.SUCCESS;

2983

} else {

2984

return ErrorCodes.ERROR_INVALID_PARAM;

}

}

@Override

public int getTimeout(int tech) throws RemoteException {

2990

NfcPermissions.enforceUserPermissions(mContext);

2991

2992

return mDeviceHost.getTimeout(tech);

}

@Override

public void resetTimeouts() throws RemoteException {

2997

NfcPermissions.enforceUserPermissions(mContext);

2998

2999

mDeviceHost.resetTimeouts();

}

@Override

public boolean canMakeReadOnly(int ndefType) throws RemoteException {

3004

return mDeviceHost.canMakeReadOnly(ndefType);

}

@Override

public int getMaxTransceiveLength(int tech) throws RemoteException {

3009

return mDeviceHost.getMaxTransceiveLength(tech);

}

@Override

public boolean getExtendedLengthApdusSupported() throws RemoteException {

3014

return mDeviceHost.getExtendedLengthApdusSupported();

}

}

final class NfcJcopService extends IJcopService.Stub{

3019

3020

public int jcopOsDownload(String pkg) throws RemoteException

3021

{

3022

NfcService.this.enforceNfceeAdminPerm(pkg);

3023

int status = ErrorCodes.SUCCESS;

3024

boolean mode;

3025

mode = mDeviceHost.doCheckJcopDlAtBoot();

3026

if(mode == false) {

3027

Log.i(TAG, "Starting getChipName");

3028

int Ver = mDeviceHost.getChipVer();

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

3029

if(Ver == PN80T_ID || Ver == PN67T_ID || Ver == PN66T_ID || Ver == PN65T_ID) {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3030

status = mDeviceHost.JCOSDownload();

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

3031

}

3032

else {

3033

status = ErrorCodes.ERROR_NOT_SUPPORTED;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3034

}

Suhas Suresh

2018-05-09 15:48:37 +0530

[diff] [blame]

3035

} else {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3036

status = ErrorCodes.ERROR_NOT_SUPPORTED;

}

return status;

}

}

final class EseClientServicesAdapter extends IeSEClientServicesAdapter.Stub{

3042

@Override

3043

public IJcopService getJcopService() {

3044

if(mJcopService == null){

3045

mJcopService = new NfcJcopService();

}

return mJcopService;

}

@Override

public ILoaderService getLoaderService() {

3051

if(mAlaService == null){

3052

mAlaService = new NfcAlaService();

}

return mAlaService;

}

@Override

public INxpExtrasService getNxpExtrasService() {

3058

if(mNxpExtras == null){

3059

mNxpExtras = new NxpExtrasService();

}

return mNxpExtras;

}

};

final class NfcAlaService extends ILoaderService.Stub{

3066

private boolean isRecovery = false;

3067

private String appName = null;

3068

private String srcIn = null;

3069

private String respOut = null;

3070

private String status = "false";

void NfcAlaService()

{

appName = null;

srcIn = null;

respOut = null;

status = "false";

isRecovery = false;

}

private synchronized void LSReexecute()

3081

{

3082

byte[] ret = {0x4E,0x02,(byte)0x69,(byte)0x87};

3083

byte retry = LS_RETRY_CNT;

3084

PrintWriter out= null;

3085

BufferedReader br = null;

3086

Log.i(TAG, "Enter: NfcAlaService constructor");

3087

try{

3088

File f = new File(LS_BACKUP_PATH);

3089

3090

Log.i(TAG, "Enter: NfcAlaService constructor file open");

3091

/*If the file does not exists*/

3092

if(!(f.isFile()))

3093

{

3094

Log.i(TAG, "FileNotFound ls backup");

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

3095

this.status = null;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3096

}

3097

/*If the file exists*/

3098

else

3099

{

3100

Log.i(TAG, "File Found ls backup");

3101

br = new BufferedReader(new FileReader(LS_BACKUP_PATH));

3102

this.appName = br.readLine();

3103

this.srcIn = br.readLine();

3104

this.respOut = br.readLine();

3105

this.status = br.readLine();

3106

}

3107

}catch(FileNotFoundException f)

3108

{

3109

Log.i(TAG, "FileNotFoundException Raised during LS Initialization");

3110

return;

3111

}

3112

catch(IOException ie)

3113

{

3114

Log.i(TAG, "IOException Raised during LS Initialization ");

return;

}

finally{

try{

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3119

if(br != null)

3120

br.close();

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

3121

/*If the file does not exist or empty file */

3122

if(this.status == null)

3123

{

3124

out = new PrintWriter(LS_BACKUP_PATH);

3125

this.status = "true";

out.println("null");

out.println("null");

out.println("null");

out.println("true");

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3131

}catch(IOException e)

3132

{

3133

Log.i(TAG, "IOException Raised during LS Initialization ");

3134

return;

3135

}

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

3136

finally{

3137

if(this.status == null)

3138

this.status = "true";

3139

if(out != null)

3140

out.close();

3141

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3142

}

3143

if(this.status.equals("true"))

3144

{

3145

Log.i(TAG, "LS Script execution completed");

}

else

{

Log.i(TAG, "LS Script execution aborted or tear down happened");

3150

Log.i(TAG, "Input script path"+ this.srcIn);

3151

Log.i(TAG, "Output response path"+ this.respOut);

3152

Log.i(TAG, "Application name which invoked LS"+ this.appName);

3153

try{

3154

File fSrc = new File(this.srcIn);

3155

File fRsp = new File(this.respOut);

3156

if((fSrc.isFile() && fRsp.isFile()))

3157

{

3158

byte[] lsAppletStatus = {0x6F,0x00};

3159

/*Perform lsExecuteScript on tear down*/

3160

WatchDogThread watchDog =

3161

new WatchDogThread("Loader service ", INIT_WATCHDOG_LS_MS);

3162

watchDog.start();

3163

try {

3164

mRoutingWakeLock.acquire();

3165

try {

3166

/*Reset retry counter*/

while((retry-- > 0))

{

Thread.sleep(1000);

lsAppletStatus = mNfcAla.doLsGetAppletStatus();

3171

if((lsAppletStatus[0]==0x63) && (lsAppletStatus[1]==0x40))

3172

{

3173

Log.i(TAG, "Started LS recovery since previous session failed");

3174

this.isRecovery = true;

3175

ret = this.lsExecuteScript(this.srcIn, this.respOut);

}

else

{

break;

}

}

} finally {

this.isRecovery = false;

3184

watchDog.cancel();

3185

mRoutingWakeLock.release();

3186

}

3187

}

3188

catch(RemoteException ie)

3189

{

3190

Log.i(TAG, "LS recovery Exception: ");

3191

}

3192

lsAppletStatus = mNfcAla.doLsGetAppletStatus();

3193

if((lsAppletStatus[0]==(byte)0x90)&&(lsAppletStatus[1]==(byte)0x00))

3194

{

3195

out = new PrintWriter(LS_BACKUP_PATH);

out.println("null");

out.println("null");

out.println("null");

out.println("true");

out.close();

Log.i(TAG, "Commiting Default Values of Loader Service AS RETRY ENDS: ");

}

}

else

{

Log.i(TAG, "LS recovery not required");

3207

}

3208

}catch(InterruptedException re)

3209

{

3210

/*Retry failed todo*/

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

3211

Log.i(TAG, "InterruptedException while LS recovery");

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3212

}catch(FileNotFoundException re)

3213

{

3214

/*Retry failed todo*/

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

3215

Log.i(TAG, "FileNotFoundException while LS recovery");

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

}

}

private void updateLoaderService() {

3220

byte[] ret = {0x4E,0x02,(byte)0x69,(byte)0x87};

3221

Log.i(TAG, "Enter: NfcAlaService constructor file open");

3222

File f = new File(LS_UPDATE_BACKUP_PATH);

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

3223

/*If the file exists*/

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3224

if((f.isFile()))

3225

{

3226

Log.i(TAG, "File Found LS update required");

3227

WatchDogThread watchDog =

3228

new WatchDogThread("LS Update Loader service ", (INIT_WATCHDOG_LS_MS+INIT_WATCHDOG_LS_MS));

watchDog.start();

try {

try {

/*Reset retry counter*/

3233

{

3234

Log.i(TAG, "Started LS update");

3235

ret = this.lsExecuteScript(LS_UPDATE_BACKUP_PATH, LS_UPDATE_BACKUP_OUT_PATH);

3236

if(ret[2] == (byte)(0x90) && ret[3] == (byte)(0x00))

3237

{

3238

Log.i(TAG, " LS update successfully completed");

3239

f.delete();

3240

} else {

3241

Log.i(TAG, " LS update failed");

}

}

} finally {

watchDog.cancel();

}

}

catch(RemoteException ie)

3249

{

3250

Log.i(TAG, "LS update recovery Exception: ");

3251

}

3252

}

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

3253

/*If the file does not exists*/

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3254

else

3255

{

3256

Log.i(TAG, "No LS update");

}

}

public byte[] lsExecuteScript( String srcIn, String respOut) throws RemoteException {

3261

String pkg_name = getCallingAppPkg(mContext);

3262

byte[] sha_data = CreateSHA(pkg_name, 2);

3263

byte[] respSW = {0x4e,0x02,0x69,(byte)0x87};

3264

InputStream is = null;

3265

OutputStream os = null;

3266

PrintWriter out = null;

3267

FileReader fr = null;

3268

byte[] buffer = new byte[1024];

3269

int length = 0;

3270

String srcBackup = srcIn+"mw";

3271

String rspBackup = null;

3272

File rspFile = null;

3273

if(respOut != null)

3274

rspBackup = respOut+"mw";

3275

File srcFile = new File(srcBackup);

3276

if(respOut != null)

3277

rspFile = new File(rspBackup);

3278

3279

3280

/*If Previously Tear down happened before completion of LS execution*/

3281

if(this.isRecovery != false)

3282

{

3283

try{

3284

fr = new FileReader(LS_BACKUP_PATH);

3285

if(fr != null)

3286

{

3287

BufferedReader br = new BufferedReader(fr);

3288

if(br != null)

3289

{

3290

String appName = br.readLine();

3291

if(appName != null)

3292

{

3293

sha_data = CreateSHA(appName, 2);

pkg_name = appName;

}

}

}

}catch(IOException ioe)

3299

{

3300

Log.i(TAG, "IOException thrown for opening ");

}

finally{

try{

if(fr != null)

fr.close();

}

catch(IOException e)

{

Log.i(TAG, "IOException thrown for opening ");

}

}

}

/*Store it in File*/

try{

out = new PrintWriter(LS_BACKUP_PATH);

3316

out.println(pkg_name);

3317

out.println(srcIn);

3318

out.println(respOut);

3319

out.println(false);

3320

}catch(IOException fe)

3321

{

3322

Log.i(TAG, "IOException thrown during clearing ");

}

finally{

if(out != null)

out.close();

}

try{

/*To avoid rewriting of backup file*/

3330

if(!(this.isRecovery)){

3331

is = new FileInputStream(srcIn);

3332

os = new FileOutputStream(srcBackup);

3333

3334

while((length = is.read(buffer))>0)

3335

{

3336

os.write(buffer,0,length);

3337

}

3338

if(is != null)is.close();

3339

if(os != null)os.close();}

3340

Log.i(TAG, "sha_data len : " + sha_data.length);

3341

Log.i(TAG, "Calling package APP Name is "+ pkg_name);

3342

if(sha_data != null)

3343

{

3344

respSW = mNfcAla.doLsExecuteScript(srcBackup, rspBackup, sha_data);

3345

}

3346

/*resp file is not null*/

3347

if(respOut != null){

3348

is = new FileInputStream(rspBackup);

3349

os = new FileOutputStream(respOut);

3350

length = 0;

3351

while((length = is.read(buffer))>0)

3352

{

3353

os.write(buffer,0,length);

3354

}

3355

}

3356

if(is != null)is.close();

3357

if(os != null)os.close();

3358

}catch(IOException ioe)

3359

{

3360

Log.i(TAG, "LS File not found");

3361

}catch(SecurityException se)

3362

{

3363

Log.i(TAG, "LS File access permission deneied");

3364

}

3365

finally{

3366

byte[] status = mNfcAla.doLsGetStatus();

3367

Log.i(TAG, "LS getStatus return SW1 : "+status[0]);

3368

Log.i(TAG, "LS getStatus return SW2: "+status[1]);

3369

if((status[0]== (byte)0x90) && (status[1] == 0x00))

3370

{

3371

try{

3372

out = new PrintWriter(LS_BACKUP_PATH);

out.println("null");

out.println("null");

out.println("null");

out.println("true");

}catch(IOException fe)

3378

{

3379

Log.i(TAG, "FileNotFoundException thrown during clearing ");

}

finally

{

if(out != null)

out.close();

}

Log.i(TAG, "COMMITTING THE DEFAULT VALUES OF LS : ");

srcFile.delete();

rspFile.delete();

}

else

{

Log.i(TAG, "NOT COMMITTING THE DEFAULT VALUES OF LS : ");

}

}

return respSW;

}

public byte[] lsGetVersion()

3398

{

3399

byte[] respApdu = {0x4e,0x02,0x69,(byte)0x87};

3400

3401

respApdu = mNfcAla.doLsGetVersion();

3402

return respApdu;

3403

}

3404

public int appletLoadApplet(String pkg, String choice) throws RemoteException {

3405

String pkg_name = getCallingAppPkg(mContext);

3406

int state = 0;

3407

byte[] sha_data = CreateSHA(pkg_name, 1);

3408

Log.i(TAG, "sha_data len : " + sha_data.length);

if(sha_data != null)

{

state = mNfcAla.doAppletLoadApplet(choice, sha_data);

return state;

}

else

return 0xFF;

}

public int getListofApplets(String pkg, String[] name) throws RemoteException {

3419

int cnt = mNfcAla.GetAppletsList(name);

3420

Log.i(TAG, "GetListofApplets count : " + cnt);

3421

for(int i=0;i<cnt;i++) {

3422

Log.i(TAG, "GetListofApplets " + name[i]);

}

return cnt;

}

nxpandroid

2017-02-24 16:08:04 +0530

[diff] [blame]

3428

//Just Stub for compilation.

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3429

public byte[] getKeyCertificate() throws RemoteException {

return null;

}

};

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3435

final class NxpExtrasService extends INxpExtrasService.Stub {

3436

private Bundle writeNoException() {

3437

Bundle p = new Bundle();

p.putInt("e", 0);

return p;

}

private Bundle writeEeException(int exceptionType, String message) {

3443

Bundle p = new Bundle();

3444

p.putInt("e", exceptionType);

3445

p.putString("m", message);

return p;

}

@Override

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

3450

public Bundle getCallingAppPkg(String pkg, IBinder b) throws RemoteException {

3451

NfcService.this.enforceNfceeAdminPerm(pkg);

Bundle result;

String packageName;

try{

packageName = NfcService.this.getCallingAppPkg(mContext);

3456

result = writeNoException();

3457

result.putString("packageName", packageName);

3458

} catch(Exception e){

3459

result = writeEeException(EE_ERROR_IO, e.getMessage());

}

return result;

}

@Override

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3465

public boolean isEnabled()

3466

{

3467

try {

3468

return (mState == NfcAdapter.STATE_ON);

3469

} catch (Exception e) {

3470

Log.d(TAG, "Exception " + e.getMessage());

return false;

}

}

@Override

public byte[] getSecureElementUid(String pkg) throws RemoteException {

3477

NfcService.this.enforceNfceeAdminPerm(pkg);

3478

return mDeviceHost.getSecureElementUid();

}

@Override

public Bundle open(String pkg, IBinder b) throws RemoteException {

3483

NfcService.this.enforceNfceeAdminPerm(pkg);

3484

3485

Bundle result;

3486

int handle = _open(b);

3487

if (handle < 0) {

3488

result = writeEeException(handle, "NFCEE open exception.");

3489

} else {

3490

result = writeNoException();

}

return result;

}

/**

* Opens a connection to the secure element.

3497

*

3498

* @return A handle with a value >= 0 in case of success, or a

3499

* negative value in case of failure.

3500

*/

3501

private int _open(IBinder b) {

3502

synchronized(NfcService.this) {

3503

if (!isNfcEnabled()) {

3504

return EE_ERROR_NFC_DISABLED;

3505

}

3506

if (mInProvisionMode) {

3507

// Deny access to the NFCEE as long as the device is being setup

3508

return EE_ERROR_IO;

3509

}

nxpandroid

e68208c

2017-02-24 16:08:04 +0530

[diff] [blame]

3510

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3511

if (mOpenEe != null) {

3512

return EE_ERROR_ALREADY_OPEN;

3513

}

3514

3515

boolean restorePolling = false;

3516

if (mNfcPollingEnabled) {

3517

// Disable polling for tags/P2P when connecting to the SMX

3518

// on PN544-based devices. Whenever nfceeClose is called,

3519

// the polling configuration will be restored.

3520

mDeviceHost.disableDiscovery();

3521

mNfcPollingEnabled = false;

3522

restorePolling = true;

3523

}

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

3524

int handle = doOpenSecureElementConnection(0xF3);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3525

if (handle < 0) {

3526

3527

if (restorePolling) {

3528

mDeviceHost.enableDiscovery(mCurrentDiscoveryParameters, true);

3529

mNfcPollingEnabled = true;

3530

}

3531

return handle;

3532

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3533

3534

mOpenEe = new OpenSecureElement(getCallingPid(), handle, b);

3535

try {

3536

b.linkToDeath(mOpenEe, 0);

3537

} catch (RemoteException e) {

3538

mOpenEe.binderDied();

3539

}

3540

3541

// Add the calling package to the list of packages that have accessed

3542

// the secure element.

3543

for (String packageName : mContext.getPackageManager().getPackagesForUid(getCallingUid())) {

3544

mSePackages.add(packageName);

}

return handle;

}

}

@Override

public Bundle close(String pkg, IBinder binder) throws RemoteException {

3553

NfcService.this.enforceNfceeAdminPerm(pkg);

Bundle result;

try {

_nfcEeClose(getCallingPid(), binder);

3558

result = writeNoException();

3559

} catch (IOException e) {

3560

result = writeEeException(EE_ERROR_IO, e.getMessage());

}

return result;

}

@Override

public Bundle transceive(String pkg, byte[] in) throws RemoteException {

3566

NfcService.this.enforceNfceeAdminPerm(pkg);

Bundle result;

byte[] out;

try {

out = _transceive(in);

3572

result = writeNoException();

3573

result.putByteArray("out", out);

3574

} catch (IOException e) {

3575

result = writeEeException(EE_ERROR_IO, e.getMessage());

}

return result;

}

private byte[] _transceive(byte[] data) throws IOException {

3581

synchronized(NfcService.this) {

3582

if (!isNfcEnabled()) {

3583

throw new IOException("NFC is not enabled");

3584

}

3585

if (mOpenEe == null) {

3586

throw new IOException("NFC EE is not open");

3587

}

3588

if (getCallingPid() != mOpenEe.pid) {

3589

throw new SecurityException("Wrong PID");

}

}

return doTransceive(mOpenEe.handle, data);

3594

}

3595

};

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3596

Bhupendra Pawar

2018-01-11 17:05:27 +0530

[diff] [blame]

3597

3598

final class NfcDtaService extends INfcDta.Stub {

3599

public void enableDta() throws RemoteException {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3600

NfcPermissions.enforceAdminPermissions(mContext);

Bhupendra Pawar

2018-01-11 17:05:27 +0530

[diff] [blame]

3601

if(!sIsDtaMode) {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3602

mDeviceHost.enableDtaMode();

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

3603

sIsDtaMode = true;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3604

Log.d(TAG, "DTA Mode is Enabled ");

Bhupendra Pawar

2018-01-11 17:05:27 +0530

[diff] [blame]

}

}

public void disableDta() throws RemoteException {

3609

NfcPermissions.enforceAdminPermissions(mContext);

3610

if(sIsDtaMode) {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3611

mDeviceHost.disableDtaMode();

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

3612

sIsDtaMode = false;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3613

}

Bhupendra Pawar

2018-01-11 17:05:27 +0530

[diff] [blame]

3614

}

3615

3616

public boolean enableServer(String serviceName, int serviceSap, int miu,

3617

int rwSize,int testCaseId) throws RemoteException {

3618

NfcPermissions.enforceAdminPermissions(mContext);

3619

3620

if(serviceName.equals(null))

3621

return false;

3622

3623

mP2pLinkManager.enableExtDtaSnepServer(serviceName, serviceSap, miu, rwSize,testCaseId);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

return true;

}

Bhupendra Pawar

2018-01-11 17:05:27 +0530

[diff] [blame]

3627

public void disableServer() throws RemoteException {

3628

NfcPermissions.enforceAdminPermissions(mContext);

3629

mP2pLinkManager.disableExtDtaSnepServer();

3630

}

3631

3632

public boolean enableClient(String serviceName, int miu, int rwSize,

3633

int testCaseId) throws RemoteException {

3634

NfcPermissions.enforceAdminPermissions(mContext);

if(testCaseId == 0)

return false;

if (testCaseId>20){

sIsShortRecordLayout=true;

3641

testCaseId=testCaseId-20;

3642

} else {

3643

sIsShortRecordLayout=false;

3644

}

3645

Log.d("testCaseId", ""+testCaseId);

3646

mP2pLinkManager.enableDtaSnepClient(serviceName, miu, rwSize, testCaseId);

return true;

}

public void disableClient() throws RemoteException {

3651

NfcPermissions.enforceAdminPermissions(mContext);

3652

mP2pLinkManager.disableDtaSnepClient();

3653

}

3654

3655

public boolean registerMessageService(String msgServiceName)

3656

throws RemoteException {

3657

NfcPermissions.enforceAdminPermissions(mContext);

3658

if(msgServiceName.equals(null))

3659

return false;

3660

3661

DtaServiceConnector.setMessageService(msgServiceName);

3662

return true;

3663

}

3664

};

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3665

3666

final class NfcVzwService extends INfcVzw.Stub {

3667

@Override

3668

public void setScreenOffCondition(boolean enable) throws RemoteException {

3669

3670

Message msg = mHandler.obtainMessage();

3671

msg.what=MSG_SET_SCREEN_STATE;

3672

msg.arg1= (enable)?1:0;

3673

mHandler.sendMessage(msg);

}

@Override

public boolean setVzwAidList(RouteEntry[] entries)

3679

throws RemoteException {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3680

Log.i(TAG, "setVzwAidList enter");

3681

Log.i(TAG, "setVzwAidList entries length =" + entries.length);

3682

if (mIsHceCapable) {

3683

mAidRoutingManager.ClearVzwCache();

3684

for (int i = 0; i < entries.length; i++) {

3685

RouteEntry routeEntry = entries[i];

3686

mAidRoutingManager.UpdateVzwCache(routeEntry.getAid(),

3687

routeEntry.getLocation(), routeEntry.getPowerState(),

3688

routeEntry.isAllowed());

3689

3690

Log.i(TAG,

3691

"AID" + routeEntry.getAid() + "Location "

3692

+ routeEntry.getLocation() + "powerstate "

3693

+ routeEntry.getPowerState());

3694

}

3695

mAidRoutingManager.onNfccRoutingTableCleared();

3696

mCardEmulationManager.onRoutingTableChanged();

return true;

} else {

return false;

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

};

void _nfcEeClose(int callingPid, IBinder binder) throws IOException {

3706

// Blocks until a pending open() or transceive() times out.

3707

//TODO: This is incorrect behavior - the close should interrupt pending

3708

// operations. However this is not supported by current hardware.

3709

3710

synchronized (NfcService.this) {

3711

if (!isNfcEnabledOrShuttingDown()) {

3712

throw new IOException("NFC adapter is disabled");

3713

}

3714

if (mOpenEe == null) {

3715

throw new IOException("NFC EE closed");

3716

}

3717

if (callingPid != -1 && callingPid != mOpenEe.pid) {

3718

throw new SecurityException("Wrong PID");

3719

}

3720

if (mOpenEe.binder != binder) {

3721

throw new SecurityException("Wrong binder handle");

3722

}

3723

3724

binder.unlinkToDeath(mOpenEe, 0);

3725

mDeviceHost.resetTimeouts();

3726

doDisconnect(mOpenEe.handle);

3727

mOpenEe = null;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

}

boolean _nfcEeReset() throws IOException {

3732

synchronized (NfcService.this) {

3733

if (!isNfcEnabledOrShuttingDown()) {

3734

throw new IOException("NFC adapter is disabled");

3735

}

3736

if (mOpenEe == null) {

3737

throw new IOException("NFC EE closed");

3738

}

3739

return mSecureElement.doReset(mOpenEe.handle);

}

}

final class NfcAccessExtrasService extends INxpNfcAccessExtras.Stub {

3744

public boolean checkChannelAdminAccess(String pkg) throws RemoteException {

3745

boolean result = true;

3746

try {

3747

NfcService.this.enforceNfcSccAdminPerm(pkg);

3748

} catch (Exception e) {

e.printStackTrace();

result = false;

}

return result;

}

};

final class NfcAdapterExtrasService extends INfcAdapterExtras.Stub {

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

3757

ActivityManager activityManager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3758

private Bundle writeNoException() {

3759

Bundle p = new Bundle();

p.putInt("e", 0);

return p;

}

private Bundle writeEeException(int exceptionType, String message) {

3765

Bundle p = new Bundle();

3766

p.putInt("e", exceptionType);

3767

p.putString("m", message);

return p;

}

@Override

public Bundle open(String pkg, IBinder b) throws RemoteException {

3773

NfcService.this.enforceNfceeAdminPerm(pkg);

3774

3775

Bundle result;

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

3776

if (activityManager.isLowRamDevice()) {

3777

result = writeEeException(SE_ACCESS_DENIED, "SE open access denied.");

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3778

} else {

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

3779

int handle = _open(b);

3780

if (handle < 0) {

3781

result = writeEeException(handle, "NFCEE open exception.");

3782

} else {

3783

result = writeNoException();

3784

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

return result;

}

/**

* Opens a connection to the secure element.

3791

*

3792

* @return A handle with a value >= 0 in case of success, or a

3793

* negative value in case of failure.

3794

*/

3795

private int _open(IBinder b) {

3796

synchronized(NfcService.this) {

3797

if (!isNfcEnabled()) {

3798

return EE_ERROR_NFC_DISABLED;

3799

}

3800

if (mInProvisionMode) {

3801

// Deny access to the NFCEE as long as the device is being setup

3802

return EE_ERROR_IO;

3803

}

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

3804

/*Concurrent access for DWP transactions to be allowed even when P2P is already ongoing */

3805

/*

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3806

if (mP2pLinkManager.isLlcpActive()) {

3807

// Don't allow PN544-based devices to open the SE while the LLCP

3808

// link is still up or in a debounce state. This avoids race

3809

// conditions in the NXP stack around P2P/SMX switching.

3810

return EE_ERROR_EXT_FIELD;

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

3811

}*/

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3812

if (mOpenEe != null) {

3813

Log.i(TAG, "SE is Busy. returning..");

3814

return EE_ERROR_ALREADY_OPEN;

3815

}

3816

boolean restorePolling = false;

3817

if (mNfcPollingEnabled) {

3818

// Disable polling for tags/P2P when connecting to the SMX

3819

// on PN544-based devices. Whenever nfceeClose is called,

3820

// the polling configuration will be restored.

3821

mDeviceHost.disableDiscovery();

3822

mNfcPollingEnabled = false;

3823

restorePolling = true;

3824

}

3825

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

3826

int handle = doOpenSecureElementConnection(0xF3);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3827

if (handle < 0) {

3828

3829

if (restorePolling) {

3830

mDeviceHost.enableDiscovery(mCurrentDiscoveryParameters, true);

3831

mNfcPollingEnabled = true;

3832

}

3833

return handle;

3834

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3835

mOpenEe = new OpenSecureElement(getCallingPid(), handle, b);

3836

try {

3837

b.linkToDeath(mOpenEe, 0);

3838

} catch (RemoteException e) {

3839

mOpenEe.binderDied();

3840

}

3841

3842

// Add the calling package to the list of packages that have accessed

3843

// the secure element.

3844

for (String packageName : mContext.getPackageManager().getPackagesForUid(getCallingUid())) {

3845

mSePackages.add(packageName);

}

return handle;

}

}

@Override

public Bundle close(String pkg, IBinder binder) throws RemoteException {

3854

NfcService.this.enforceNfceeAdminPerm(pkg);

3855

3856

Bundle result;

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

3857

3858

if (activityManager.isLowRamDevice()) {

3859

result = writeEeException(SE_ACCESS_DENIED, "SE close access denied.");

3860

} else {

3861

try {

3862

_nfcEeClose(getCallingPid(), binder);

3863

result = writeNoException();

3864

} catch (IOException e) {

3865

result = writeEeException(EE_ERROR_IO, e.getMessage());

3866

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

return result;

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3871

@Override

3872

public Bundle transceive(String pkg, byte[] in) throws RemoteException {

3873

NfcService.this.enforceNfceeAdminPerm(pkg);

3874

3875

Bundle result;

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

3876

3877

if (activityManager.isLowRamDevice()) {

3878

result = writeEeException(SE_ACCESS_DENIED, "SE transceive access denied.");

} else {

byte[] out;

try {

out = _transceive(in);

3883

result = writeNoException();

3884

result.putByteArray("out", out);

3885

} catch (IOException e) {

3886

result = writeEeException(EE_ERROR_IO, e.getMessage());

3887

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

return result;

}

private byte[] _transceive(byte[] data) throws IOException {

3893

synchronized(NfcService.this) {

3894

if (!isNfcEnabled()) {

3895

throw new IOException("NFC is not enabled");

3896

}

3897

if (mOpenEe == null) {

3898

throw new IOException("NFC EE is not open");

3899

}

3900

if (getCallingPid() != mOpenEe.pid) {

3901

throw new SecurityException("Wrong PID");

}

}

return doTransceive(mOpenEe.handle, data);

3906

}

3907

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3908

@Override

3909

public int getCardEmulationRoute(String pkg) throws RemoteException {

3910

NfcService.this.enforceNfceeAdminPerm(pkg);

3911

return mEeRoutingState;

}

@Override

public void setCardEmulationRoute(String pkg, int route) throws RemoteException {

3916

NfcService.this.enforceNfceeAdminPerm(pkg);

3917

mEeRoutingState = route;

3918

ApplyRoutingTask applyRoutingTask = new ApplyRoutingTask();

3919

applyRoutingTask.execute();

3920

try {

3921

// Block until route is set

3922

applyRoutingTask.get();

3923

} catch (ExecutionException e) {

3924

Log.e(TAG, "failed to set card emulation mode");

3925

} catch (InterruptedException e) {

3926

Log.e(TAG, "failed to set card emulation mode");

}

}

@Override

public void authenticate(String pkg, byte[] token) throws RemoteException {

3932

NfcService.this.enforceNfceeAdminPerm(pkg);

}

@Override

public String getDriverName(String pkg) throws RemoteException {

3937

NfcService.this.enforceNfceeAdminPerm(pkg);

3938

return mDeviceHost.getName();

}

}

final class NxpNfcAdapterExtrasService extends INxpNfcAdapterExtras.Stub {

3943

private Bundle writeNoException() {

3944

Bundle p = new Bundle();

p.putInt("e", 0);

return p;

}

private Bundle writeEeException(int exceptionType, String message) {

3950

Bundle p = new Bundle();

3951

p.putInt("e", exceptionType);

3952

p.putString("m", message);

3953

return p;

3954

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3955

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

3956

@Override

3957

public boolean eSEChipReset(String pkg) throws RemoteException {

3958

NfcService.this.enforceNfceeAdminPerm(pkg);

3959

Bundle result;

3960

boolean stat = false;

3961

try {

3962

synchronized (NfcService.this) {

3963

if (!isNfcEnabledOrShuttingDown()) {

3964

throw new IOException("NFC adapter is disabled");

3965

}

3966

if (mOpenEe == null) {

3967

throw new IOException("NFC EE closed");

3968

}

3969

stat = mSecureElement.doeSEChipReset();

3970

}

3971

result = writeNoException();

3972

} catch (IOException e) {

3973

result = writeEeException(EE_ERROR_IO, e.getMessage());

}

return stat;

}

@Override

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

3979

public boolean reset(String pkg) throws RemoteException {

3980

NfcService.this.enforceNfceeAdminPerm(pkg);

3981

Bundle result;

3982

boolean stat = false;

3983

try {

3984

stat = _nfcEeReset();

3985

result = writeNoException();

3986

} catch (IOException e) {

3987

result = writeEeException(EE_ERROR_IO, e.getMessage());

3988

}

3989

Log.d(TAG,"reset" + stat);

return stat;

}

boolean _nfcEeReset() throws IOException {

3994

synchronized (NfcService.this) {

3995

if (!isNfcEnabledOrShuttingDown()) {

3996

throw new IOException("NFC adapter is disabled");

3997

}

3998

if (mOpenEe == null) {

3999

throw new IOException("NFC EE closed");

4000

}

4001

return mSecureElement.doReset(mOpenEe.handle);

}

}

@Override

public int getSecureElementTechList(String pkg) throws RemoteException {

4007

NfcService.this.enforceNfceeAdminPerm(pkg);

4008

return mDeviceHost.doGetSecureElementTechList();

}

@Override

public byte[] getSecureElementUid(String pkg) throws RemoteException {

4013

NfcService.this.enforceNfceeAdminPerm(pkg);

4014

return mDeviceHost.getSecureElementUid();

}

@Override

public void notifyCheckCertResult(String pkg, boolean success)

4019

throws RemoteException {

4020

if (DBG) Log.d(TAG, "notifyCheckCertResult() " + pkg + ", success=" + success);

4021

4022

NfcService.this.enforceNfceeAdminPerm(pkg);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4023

mNxpNfcController.setResultForX509Certificates(success);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

@Override

public void deliverSeIntent(String pkg, Intent seIntent)

4028

throws RemoteException {

4029

Log.d(TAG, "deliverSeIntent() " + pkg + " " + seIntent.getAction());

4030

NfcService.this.enforceNfceeAdminPerm(pkg);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4031

sendMessage(MSG_SE_DELIVER_INTENT, seIntent);

}

@Override

public byte[] doGetRouting() throws RemoteException {

4036

return mDeviceHost.doGetRouting();

}

@Override

public Bundle getAtr(String pkg) throws RemoteException {

4041

NfcService.this.enforceNfceeAdminPerm(pkg);

Bundle result;

byte[] out;

try {

out = _getAtr();

result = writeNoException();

4048

result.putByteArray("out", out);

4049

} catch (IOException e) {

4050

result = writeEeException(EE_ERROR_IO, e.getMessage());

4051

}

4052

Log.d(TAG,"getAtr result " + result);

return result;

}

private byte[] _getAtr() throws IOException {

4057

synchronized(NfcService.this) {

4058

if (!isNfcEnabled()) {

4059

throw new IOException("NFC is not enabled");

4060

}

4061

if (mOpenEe == null) {

4062

throw new IOException("NFC EE is not open");

4063

}

4064

if (getCallingPid() != mOpenEe.pid) {

4065

throw new SecurityException("Wrong PID");

4066

}

4067

}

4068

return mSecureElement.doGetAtr(mOpenEe.handle);

4069

}

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

4070

@Override

4071

public int selectUicc(int uiccSlot) throws RemoteException {

4072

synchronized(NfcService.this) {

4073

if (!isNfcEnabled()) {

4074

throw new RemoteException("NFC is not enabled");

4075

}

4076

int status = mDeviceHost.doselectUicc(uiccSlot);

4077

Log.i(TAG, "Update routing table");

4078

/*In case of UICC connected and Enabled or Removed ,

4079

*Reconfigure the routing table based on current UICC parameters

4080

**/

4081

if((status == 0x00)||(status == 0x01))

4082

{

nxpandroid

2016-12-22 18:48:59 +0530

[diff] [blame]

4083

mPrefsEditor.putInt(PREF_CUR_SELECTED_UICC_ID, uiccSlot);

4084

mPrefsEditor.apply();

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

4085

if((mAidRoutingManager != null) && (mCardEmulationManager != null))

4086

{

4087

Log.i(TAG, "Update routing table");

4088

mAidRoutingManager.onNfccRoutingTableCleared();

nxpandroid

810c477

2017-04-10 18:28:54 +0530

[diff] [blame]

4089

mIsRoutingTableDirty = true;

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

4090

mCardEmulationManager.onNfcEnabled();

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

}

else

{

Log.i(TAG, "Update only Mifare and Desfire route");

4095

mIsRoutingTableDirty = true;

applyRouting(false);

}

}

return status;

}

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4102

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

4103

@Override

4104

public int getSelectedUicc() throws RemoteException {

4105

if (!isNfcEnabled()) {

4106

throw new RemoteException("NFC is not enabled");

4107

}

4108

return mDeviceHost.doGetSelectedUicc();

4109

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4110

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

4111

@Override

4112

public Bundle openuicc(String pkg, IBinder b) throws RemoteException {

4113

NfcService.this.enforceNfceeAdminPerm(pkg);

4114

4115

Bundle result;

4116

int handle = _openuicc(b);

4117

if (handle < 0) {

4118

result = writeEeException(handle, "NFCEE UICC open exception.");

4119

} else {

4120

result = writeNoException();

}

return result;

}

/**

* Opens a connection to the UICC element.

4127

*

4128

* @return A handle with a value >= 0 in case of success, or a

4129

* negative value in case of failure.

4130

*/

4131

private int _openuicc(IBinder b) {

4132

synchronized(NfcService.this) {

4133

if (!isNfcEnabled()) {

4134

return EE_ERROR_NFC_DISABLED;

4135

}

4136

if (mInProvisionMode) {

4137

// Deny access to the NFCEE as long as the device is being setup

4138

return EE_ERROR_IO;

4139

}

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

4140

if (mOpenEe != null) {

4141

return EE_ERROR_ALREADY_OPEN;

4142

}

4143

4144

boolean restorePolling = false;

4145

if (mNfcPollingEnabled) {

4146

// Disable polling for tags/P2P when connecting to the SMX

4147

// on PN544-based devices. Whenever nfceeClose is called,

4148

// the polling configuration will be restored.

4149

mDeviceHost.disableDiscovery();

4150

mNfcPollingEnabled = false;

4151

restorePolling = true;

4152

}

4153

4154

int handle = doOpenSecureElementConnection(0xF4);

4155

if (handle < 0) {

4156

4157

if (restorePolling) {

4158

mDeviceHost.enableDiscovery(mCurrentDiscoveryParameters, true);

4159

mNfcPollingEnabled = true;

4160

}

4161

return handle;

4162

}

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

4163

4164

mOpenEe = new OpenSecureElement(getCallingPid(), handle, b);

4165

try {

4166

b.linkToDeath(mOpenEe, 0);

4167

} catch (RemoteException e) {

4168

mOpenEe.binderDied();

4169

}

4170

4171

// Add the calling package to the list of packages that have accessed

4172

// the secure element.

4173

for (String packageName : mContext.getPackageManager().getPackagesForUid(getCallingUid())) {

4174

mSePackages.add(packageName);

}

return handle;

}

}

@Override

public Bundle closeuicc(String pkg, IBinder binder) throws RemoteException {

4183

NfcService.this.enforceNfceeAdminPerm(pkg);

Bundle result;

try {

Log.w("Nxp", "Close UICC!");

4188

_nfcEeClose(getCallingPid(), binder);

4189

result = writeNoException();

4190

} catch (IOException e) {

4191

result = writeEeException(EE_ERROR_IO, e.getMessage());

}

return result;

}

@Override

public Bundle transceiveuicc(String pkg, byte[] in) throws RemoteException {

4198

NfcService.this.enforceNfceeAdminPerm(pkg);

Bundle result;

byte[] out;

try {

out = _transceiveuicc(in);

4204

result = writeNoException();

4205

result.putByteArray("out", out);

4206

} catch (IOException e) {

4207

result = writeEeException(EE_ERROR_IO, e.getMessage());

}

return result;

}

private byte[] _transceiveuicc(byte[] data) throws IOException {

4213

synchronized(NfcService.this) {

4214

if (!isNfcEnabled()) {

4215

throw new IOException("NFC is not enabled");

4216

}

4217

if (mOpenEe == null) {

4218

throw new IOException("NFC EE is not open");

4219

}

4220

if (getCallingPid() != mOpenEe.pid) {

4221

throw new SecurityException("Wrong PID");

}

}

return doTransceive(mOpenEe.handle, data);

4226

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4227

}

4228

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

4229

final class NfcWiredSe extends ISecureElement.Stub {

4230

4231

int mNfcWiredSeHandle = 0;

4232

byte mOpenedchannelCount = 0;

Nikhil Chhabra

2018-04-18 11:18:35 +0530

[diff] [blame]

4233

boolean mIsSecureElementOpened = false;

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

4234

Nikhil Chhabra

2018-04-18 11:18:35 +0530

[diff] [blame]

4235

private void closeNfcWiredSeService() {

4236

if (mSecureElementclientCallback != null) {

4237

try {

4238

mSecureElementclientCallback.onStateChange(false);

4239

} catch (RemoteException re) {

4240

Log.e(TAG, "Exception while executing NfcWiredSe callback");

4241

}

4242

}

4243

mNfcSeService.nfcWiredSeDeInit();

4244

mNfcSeService.mOpenedchannelCount = 0;

4245

mSecureElementclientCallback = null;

4246

}

4247

4248

private boolean isSecureElementPresent(int secureElementId) {

4249

int[] seList = mDeviceHost.doGetSecureElementList();

4250

boolean isSePresent = false;

4251

for (int i = 0; i < seList.length; i++) {

4252

if (seList[i] == secureElementId) {

isSePresent = true;

break;

}

}

return isSePresent;

}

private byte nfcWiredSeDeInit() {

4261

if (mIsSecureElementOpened) {

4262

doDisconnect(mNfcWiredSeHandle);

4263

}

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

4264

mNfcWiredSeHandle = 0;

4265

mIsSecureElementOpened = false;

4266

return SecureElementStatus.SUCCESS;

}

@Override

public byte closeChannel(byte channelNumber) throws android.os.RemoteException {

4271

byte status = SecureElementStatus.FAILED;

4272

if(channelNumber < DEFAULT_BASIC_CHANNEL ||

4273

channelNumber >= MAX_LOGICAL_CHANNELS) {

4274

status = SecureElementStatus.FAILED;

4275

} else if(channelNumber > DEFAULT_BASIC_CHANNEL) {

4276

byte[] closeCommand = new byte[5];

4277

closeCommand[0] = channelNumber;

4278

closeCommand[1] = (byte)0x70;

4279

closeCommand[2] = (byte)0x80;

4280

closeCommand[3] = channelNumber;

4281

closeCommand[4] = 0x00;

4282

byte[] resp = doTransceive(mNfcWiredSeHandle, closeCommand);

4283

if (resp == null || resp.length < 0) {

4284

Log.e(TAG, "WiredSe: error in close channel: IO Error");

4285

status = SecureElementStatus.IOERROR;

4286

} else if(resp[resp.length - 2] == (byte)0x90 &&

4287

resp[resp.length - 1] == (byte)0x00) {

4288

status = SecureElementStatus.SUCCESS;

4289

} else {

4290

Log.e(TAG, "WiredSe: error in close channel: "+Arrays.toString(resp));

4291

status = SecureElementStatus.FAILED;

}

}

if ((channelNumber == DEFAULT_BASIC_CHANNEL) ||

4296

(status == SecureElementStatus.SUCCESS)) {

4297

mOpenedchannelCount--;

4298

/*If there are no channels remaining close secureElement*/

4299

if (mOpenedchannelCount == 0) {

4300

Log.e(TAG, "WiredSe: channel count is 0, deinit wired se");

4301

status = nfcWiredSeDeInit();

4302

} else {

4303

status = SecureElementStatus.SUCCESS;

}

}

return status;

}

@Override

public void openBasicChannel(java.util.ArrayList<Byte> aid, byte p2, openBasicChannelCallback _hidl_cb)

4311

throws android.os.RemoteException {

4312

if(!mIsSecureElementOpened) {

4313

mNfcWiredSeHandle = doOpenSecureElementConnection(0xF3);

4314

if (mNfcWiredSeHandle < 0) {

4315

Log.e(TAG, "open secure element fails.");

4316

mNfcWiredSeHandle = 0;

4317

_hidl_cb.onValues(null, SecureElementStatus.IOERROR);

4318

return;

4319

} else {

4320

mIsSecureElementOpened = true;

4321

}

4322

}

4323

byte[] selectCommand = new byte[5 + aid.size()];

4324

selectCommand[0] = 0x00;

4325

selectCommand[1] = (byte) 0xA4;

4326

selectCommand[2] = 0x04;

4327

selectCommand[3] = 0x00; // next occurrence

4328

selectCommand[4] = (byte) aid.size();

4329

System.arraycopy(arrayListToByteArray(aid), 0, selectCommand, 5, aid.size());

4330

4331

byte[] resp = doTransceive(mNfcWiredSeHandle, selectCommand);

4332

byte status = SecureElementStatus.FAILED;

4333

if(resp == null || resp.length < 0) {

4334

Log.e(TAG, "WiredSe: error in open basic channel : IO Error");

4335

status = SecureElementStatus.IOERROR;

4336

return;

4337

} else if(resp[resp.length - 2] == (byte)0x90 &&

4338

resp[resp.length - 1] == (byte)0x00) {

4339

mOpenedchannelCount++;

4340

status = SecureElementStatus.SUCCESS;

4341

} else if(resp[resp.length - 2] == (byte)0x6A &&

4342

resp[resp.length - 1] == (byte)0x82) {

4343

status = SecureElementStatus.NO_SUCH_ELEMENT_ERROR;

4344

} else if(resp[resp.length - 2] == (byte)0x6A &&

4345

resp[resp.length - 1] == (byte)0x86) {

4346

status = SecureElementStatus.UNSUPPORTED_OPERATION;

4347

} else {

4348

Log.e(TAG, "WiredSe: open basic channel failed, response: "+Arrays.toString(resp));

4349

status = SecureElementStatus.FAILED;

4350

}

4351

if (status != SecureElementStatus.SUCCESS) {

4352

if(mOpenedchannelCount > DEFAULT_BASIC_CHANNEL) {

4353

closeChannel((byte)DEFAULT_BASIC_CHANNEL);

4354

}

4355

}

4356

_hidl_cb.onValues(byteArrayToArrayList(resp), (byte)status);

return;

}

@Override

public void openLogicalChannel(java.util.ArrayList<Byte> aid,

4362

byte p1, openLogicalChannelCallback _hidl_cb)

4363

throws android.os.RemoteException {

4364

if(!mIsSecureElementOpened) {

4365

Log.i(TAG, "WiredSe: Opening SecureElementConnection");

4366

mNfcWiredSeHandle = doOpenSecureElementConnection(0xF3);

4367

if (mNfcWiredSeHandle < 0) {

Nikhil Chhabra

2018-04-18 11:18:35 +0530

[diff] [blame]

4368

Log.e(TAG, "open secure element fails.");

4369

mNfcWiredSeHandle = 0;

4370

_hidl_cb.onValues(null, SecureElementStatus.IOERROR);

4371

return;

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

4372

} else {

4373

mIsSecureElementOpened = true;

4374

}

4375

}

4376

/* Send Manage channel command */

4377

byte[] manageChannelCommand = {0x00, 0x70, 0x00, 0x00, 0x01};

4378

byte[] respManageChannel = doTransceive(mNfcWiredSeHandle, manageChannelCommand);

4379

byte status = SecureElementStatus.FAILED;

4380

LogicalChannelResponse logicalChannelResp = new LogicalChannelResponse();

4381

logicalChannelResp.channelNumber = (byte) 0;/* To be modified after Manage Channel command*/

4382

if (respManageChannel == null || respManageChannel.length < 0) {

4383

Log.e(TAG, "WiredSe: error in open logical channel : IO Error");

4384

status = SecureElementStatus.IOERROR;

4385

logicalChannelResp.channelNumber = INVALID_LOGICAL_CHANNEL;

4386

return;

4387

} else if(respManageChannel[respManageChannel.length - 2] == (byte)0x6A &&

4388

respManageChannel[respManageChannel.length - 1] == (byte)0x81) {

4389

Log.e(TAG, "WiredSe: error in open logical channel : Channel Not Available");

4390

status = SecureElementStatus.CHANNEL_NOT_AVAILABLE;

4391

logicalChannelResp.channelNumber = INVALID_LOGICAL_CHANNEL;

4392

return;

4393

} else if(respManageChannel[respManageChannel.length - 2] == (byte)0x90 &&

4394

respManageChannel[respManageChannel.length - 1] ==(byte) 0x00) {

4395

logicalChannelResp.channelNumber = respManageChannel[0];

4396

mOpenedchannelCount++;

4397

status = SecureElementStatus.SUCCESS;

4398

} else if(((respManageChannel[respManageChannel.length - 2] == (byte)0x6E) ||

4399

(respManageChannel[respManageChannel.length - 2] == (byte)0x6D)) &&

4400

respManageChannel[respManageChannel.length - 1] == 0x00) {

4401

Log.e(TAG, "WiredSe: error in open logical channel : Unsupported operation");

4402

status = SecureElementStatus.UNSUPPORTED_OPERATION;

4403

logicalChannelResp.channelNumber = INVALID_LOGICAL_CHANNEL;

4404

}

4405

4406

if(status != SecureElementStatus.SUCCESS) {

4407

Log.e(TAG, "WiredSe: error in open logical channel : manage channel command failed");

4408

_hidl_cb.onValues(null, status);

4409

return;

4410

}

4411

byte[] selectCommand = new byte[5 + aid.size()];

4412

logicalChannelResp.channelNumber = respManageChannel[0];

4413

selectCommand[0] = respManageChannel[0];

4414

selectCommand[1] = (byte) 0xA4;

4415

selectCommand[2] = 0x04;

4416

selectCommand[3] = 0x00; // next occurrence

4417

selectCommand[4] = (byte) aid.size();

4418

System.arraycopy(arrayListToByteArray(aid), 0, selectCommand, 5, aid.size());

4419

byte[] resp = doTransceive(mNfcWiredSeHandle, selectCommand);

4420

byte sestatus = SecureElementStatus.FAILED;

4421

if(resp[resp.length - 2] == (byte)0x90 &&

4422

resp[resp.length - 1] == (byte)0x00) {

4423

sestatus = SecureElementStatus.SUCCESS;

4424

} else if(resp[resp.length - 2] == (byte)0x6A &&

4425

resp[resp.length - 1] == (byte)0x82) {

4426

sestatus = SecureElementStatus.NO_SUCH_ELEMENT_ERROR;

4427

} else if(resp[resp.length - 2] == (byte)0x6A &&

4428

resp[resp.length - 1] == (byte)0x86) {

4429

sestatus = SecureElementStatus.UNSUPPORTED_OPERATION;

4430

}

4431

if (sestatus != SecureElementStatus.SUCCESS) {

4432

closeChannel(logicalChannelResp.channelNumber);

4433

}

4434

for(int i=0; i< resp.length; i++) {

4435

logicalChannelResp.selectResponse.add(resp[i]);

4436

}

4437

_hidl_cb.onValues(logicalChannelResp, sestatus);

return;

}

@Override

public java.util.ArrayList<Byte> transmit(java.util.ArrayList<Byte> data)

4443

throws android.os.RemoteException {

4444

if (mNfcWiredSeHandle < 0) {

4445

Log.e(TAG, "WiredSe: Secure Element handle NULL");

4446

return null;

4447

} else {

4448

byte[] resp = doTransceive(mNfcWiredSeHandle, arrayListToByteArray(data));

4449

return byteArrayToArrayList(resp);

}

}

@Override

public boolean isCardPresent()

4455

throws android.os.RemoteException {

Nikhil Chhabra

2018-04-18 11:18:35 +0530

[diff] [blame]

4456

return isSecureElementPresent(SMART_MX_ID_TYPE);

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

}

@Override

public java.util.ArrayList<Byte> getAtr()

4461

throws android.os.RemoteException {

4462

synchronized(NfcService.this) {

4463

return byteArrayToArrayList(mSecureElement.doGetAtr(mNfcWiredSeHandle));

}

}

@Override

public void init(ISecureElementHalCallback clientCallback)

4469

throws android.os.RemoteException {

4470

synchronized(NfcService.this) {

4471

if(clientCallback == null) {

4472

Log.e(TAG, "WiredSe: clientCallback NULL");

4473

return;

4474

}

4475

mSecureElementclientCallback = clientCallback;

4476

mNfcWiredSeHandle = doOpenSecureElementConnection(0xF3);

4477

if (mNfcWiredSeHandle < 0) {

4478

Log.i(TAG, "open secure element fails.");

4479

clientCallback.onStateChange(false);

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

4480

mNfcWiredSeHandle = 0;

4481

} else {

4482

mIsSecureElementOpened = true;

4483

clientCallback.onStateChange(true);

Nikhil Chhabra

2018-04-11 15:28:06 +0530

[diff] [blame]

4484

Log.i(TAG, "WiredSe: Completed Opening Secure Element");

}

}

return;

}

private ArrayList<Byte> byteArrayToArrayList(byte[] array) {

4491

ArrayList<Byte> list = new ArrayList<Byte>();

4492

int i = 0;

4493

for (Byte b : array) {

list.add(b);

}

return list;

}

private byte[] arrayListToByteArray(ArrayList<Byte> list) {

4500

Byte[] byteArray = list.toArray(new Byte[list.size()]);

4501

int i = 0;

4502

byte[] result = new byte[list.size()];

4503

for (Byte b : byteArray) {

4504

result[i++] = b.byteValue();

}

return result;

}

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4510

/** resources kept while secure element is open */

4511

private class OpenSecureElement implements IBinder.DeathRecipient {

4512

public int pid; // pid that opened SE

4513

// binder handle used for DeathReceipient. Must keep

4514

// a reference to this, otherwise it can get GC'd and

4515

// the binder stub code might create a different BinderProxy

4516

// for the same remote IBinder, causing mismatched

4517

// link()/unlink()

4518

public IBinder binder;

4519

public int handle; // low-level handle

4520

public OpenSecureElement(int pid, int handle, IBinder binder) {

4521

this.pid = pid;

4522

this.handle = handle;

4523

this.binder = binder;

4524

}

4525

@Override

4526

public void binderDied() {

4527

synchronized (NfcService.this) {

4528

Log.i(TAG, "Tracked app " + pid + " died");

4529

pid = -1;

4530

try {

4531

_nfcEeClose(-1, binder);

4532

} catch (IOException e) { /* already closed */ }

}

}

@Override

public String toString() {

4537

return new StringBuilder('@').append(Integer.toHexString(hashCode())).append("[pid=")

4538

.append(pid).append(" handle=").append(handle).append("]").toString();

}

}

boolean isNfcEnabledOrShuttingDown() {

4543

synchronized (this) {

4544

return (mState == NfcAdapter.STATE_ON || mState == NfcAdapter.STATE_TURNING_OFF);

}

}

boolean isNfcEnabled() {

4549

synchronized (this) {

4550

return mState == NfcAdapter.STATE_ON;

}

}

class WatchDogThread extends Thread {

4555

final Object mCancelWaiter = new Object();

4556

final int mTimeout;

4557

boolean mCanceled = false;

4558

4559

public WatchDogThread(String threadName, int timeout) {

super(threadName);

mTimeout = timeout;

}

@Override

public void run() {

try {

synchronized (mCancelWaiter) {

4568

mCancelWaiter.wait(mTimeout);

if (mCanceled) {

return;

}

}

} catch (InterruptedException e) {

4574

// Should not happen; fall-through to abort.

4575

Log.w(TAG, "Watchdog thread interruped.");

4576

interrupt();

4577

}

4578

Log.e(TAG, "Watchdog triggered, aborting.");

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

4579

mDeviceHost.doAbort(getName());

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4580

}

4581

4582

public synchronized void cancel() {

4583

synchronized (mCancelWaiter) {

4584

mCanceled = true;

4585

mCancelWaiter.notify();

}

}

}

/* For Toast from background process*/

4591

4592

public class ToastHandler

4593

{

4594

// General attributes

4595

private Context mContext;

4596

private Handler mHandler;

4597

4598

public ToastHandler(Context _context)

4599

{

4600

this.mContext = _context;

4601

this.mHandler = new Handler();

}

/**

* Runs the <code>Runnable</code> in a separate <code>Thread</code>.

4606

*

4607

* @param _runnable

4608

* The <code>Runnable</code> containing the <code>Toast</code>

4609

*/

4610

private void runRunnable(final Runnable _runnable)

4611

{

4612

Thread thread = new Thread()

{

public void run()

{

mHandler.post(_runnable);

}

};

thread.start();

thread.interrupt();

thread = null;

}

public void showToast(final CharSequence _text, final int _duration)

4626

{

4627

final Runnable runnable = new Runnable()

{

@Override

public void run()

{

Toast.makeText(mContext, _text, _duration).show();

}

};

runRunnable(runnable);

}

}

static byte[] hexStringToBytes(String s) {

4641

if (s == null || s.length() == 0) return null;

4642

int len = s.length();

if (len % 2 != 0) {

s = '0' + s;

len++;

}

byte[] data = new byte[len / 2];

4648

for (int i = 0; i < len; i += 2) {

4649

data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)

4650

+ Character.digit(s.charAt(i + 1), 16));

}

return data;

}

static String toHexString(byte[] buffer, int offset, int length) {

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

4656

final char[] hexChars = "0123456789abcdef".toCharArray();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4657

char[] chars = new char[2 * length];

4658

for (int j = offset; j < offset + length; ++j) {

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

4659

chars[2 * (j-offset)] = hexChars[(buffer[j] & 0xF0) >>> 4];

4660

chars[2 * (j-offset) + 1] = hexChars[buffer[j] & 0x0F];

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4661

}

4662

return new String(chars);

}

/**

* Read mScreenState and apply NFC-C polling and NFC-EE routing

4667

*/

4668

void applyRouting(boolean force) {

4669

Log.d(TAG, "applyRouting - enter force = " + force + " mScreenState = " + mScreenState);

4670

4671

synchronized (this) {

4672

//Since Reader mode during wired mode is supported

4673

//enableDiscovery or disableDiscovery is allowed

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4674

if (!isNfcEnabledOrShuttingDown()) {

4675

// PN544 cannot be reconfigured while EE is open

4676

return;

4677

}

4678

WatchDogThread watchDog = new WatchDogThread("applyRouting", ROUTING_WATCHDOG_MS);

4679

if (mInProvisionMode) {

4680

mInProvisionMode = Settings.Secure.getInt(mContentResolver,

4681

Settings.Global.DEVICE_PROVISIONED, 0) == 0;

4682

if (!mInProvisionMode) {

4683

// Notify dispatcher it's fine to dispatch to any package now

4684

// and allow handover transfers.

4685

mNfcDispatcher.disableProvisioningMode();

nxpandroid

1153eb3

2015-11-06 18:46:58 +0530

[diff] [blame]

4686

/* if provision mode is disabled, then send this info to lower layers as well */

4687

mDeviceHost.doSetProvisionMode(mInProvisionMode);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4688

}

4689

}

4690

// Special case: if we're transitioning to unlocked state while

4691

// still talking to a tag, postpone re-configuration.

4692

if (mScreenState == ScreenStateHelper.SCREEN_STATE_ON_UNLOCKED && isTagPresent()) {

4693

Log.d(TAG, "Not updating discovery parameters, tag connected.");

4694

mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_RESUME_POLLING),

4695

APPLY_ROUTING_RETRY_TIMEOUT_MS);

return;

}

try {

watchDog.start();

// Compute new polling parameters

4702

NfcDiscoveryParameters newParams = computeDiscoveryParameters(mScreenState);

4703

if (force || !newParams.equals(mCurrentDiscoveryParameters)) {

4704

if (newParams.shouldEnableDiscovery()) {

4705

boolean shouldRestart = mCurrentDiscoveryParameters.shouldEnableDiscovery();

4706

mDeviceHost.enableDiscovery(newParams, shouldRestart);

4707

} else {

4708

mDeviceHost.disableDiscovery();

4709

}

4710

mCurrentDiscoveryParameters = newParams;

4711

} else {

4712

Log.d(TAG, "Discovery configuration equal, not updating.");

}

} finally {

watchDog.cancel();

}

}

}

private NfcDiscoveryParameters computeDiscoveryParameters(int screenState) {

4721

// Recompute discovery parameters based on screen state

4722

NfcDiscoveryParameters.Builder paramsBuilder = NfcDiscoveryParameters.newBuilder();

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

4723

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4724

// Polling

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

4725

if ((screenState >= NFC_POLLING_MODE)||mIsTaskBoot) {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4726

// Check if reader-mode is enabled

4727

if (mReaderModeParams != null) {

4728

int techMask = 0;

4729

if ((mReaderModeParams.flags & NfcAdapter.FLAG_READER_NFC_A) != 0)

4730

techMask |= NFC_POLL_A;

4731

if ((mReaderModeParams.flags & NfcAdapter.FLAG_READER_NFC_B) != 0)

4732

techMask |= NFC_POLL_B;

4733

if ((mReaderModeParams.flags & NfcAdapter.FLAG_READER_NFC_F) != 0)

4734

techMask |= NFC_POLL_F;

4735

if ((mReaderModeParams.flags & NfcAdapter.FLAG_READER_NFC_V) != 0)

Nikhil Chhabra

288edb0

2018-01-10 19:36:21 +0530

[diff] [blame]

4736

techMask |= NFC_POLL_V;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4737

if ((mReaderModeParams.flags & NfcAdapter.FLAG_READER_NFC_BARCODE) != 0)

4738

techMask |= NFC_POLL_KOVIO;

4739

4740

paramsBuilder.setTechMask(techMask);

4741

paramsBuilder.setEnableReaderMode(true);

4742

} else {

4743

paramsBuilder.setTechMask(NfcDiscoveryParameters.NFC_POLL_DEFAULT);

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

4744

paramsBuilder.setEnableP2p(true);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4745

}

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

4746

}

4747

if ((screenState == ScreenStateHelper.SCREEN_STATE_ON_LOCKED && mInProvisionMode) &&

4748

!mNfcUnlockManager.isLockscreenPollingEnabled()) {

4749

if (mReaderModeParams != null)

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4750

paramsBuilder.setTechMask(NfcDiscoveryParameters.NFC_POLL_DEFAULT);

4751

// enable P2P for MFM/EDU/Corp provisioning

4752

paramsBuilder.setEnableP2p(true);

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

4753

} else if ((screenState == ScreenStateHelper.SCREEN_STATE_ON_LOCKED) &&

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

4754

(mIsLiveCaseEnabled || mNfcUnlockManager.isLockscreenPollingEnabled())) {

4755

int techMask = 0;

4756

// enable polling for Live Case technologies

4757

if (mIsLiveCaseEnabled)

4758

techMask |= mLiveCaseTechnology;

4759

if (mNfcUnlockManager.isLockscreenPollingEnabled())

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

4760

{

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

4761

techMask |= mNfcUnlockManager.getLockscreenPollMask();

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

4762

}

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

4763

paramsBuilder.setTechMask(techMask);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4764

paramsBuilder.setEnableLowPowerDiscovery(false);

4765

paramsBuilder.setEnableP2p(false);

4766

}

4767

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

4768

if (mIsHceCapable && mReaderModeParams == null) {

Nikhil Chhabra

e1d07ba

2018-01-10 11:33:17 +0530

[diff] [blame]

4769

// Host routing is always enabled at lock screen or later, provided we aren't in reader mode

4770

paramsBuilder.setEnableHostRouting(true);

4771

}

4772

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4773

//To make routing table update.

4774

if(mIsRoutingTableDirty) {

4775

mIsRoutingTableDirty = false;

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

4776

int protoRoute = mNxpPrefs.getInt("PREF_MIFARE_DESFIRE_PROTO_ROUTE_ID", GetDefaultMifareDesfireRouteEntry());

4777

int defaultRoute=mNxpPrefs.getInt("PREF_SET_DEFAULT_ROUTE_ID", GetDefaultRouteEntry());

4778

int techRoute=mNxpPrefs.getInt("PREF_MIFARE_CLT_ROUTE_ID", GetDefaultMifateCLTRouteEntry());

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

4779

if (DBG) Log.d(TAG, "Set default Route Entry");

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4780

setDefaultRoute(defaultRoute, protoRoute, techRoute);

4781

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4782

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4783

return paramsBuilder.build();

4784

}

4785

4786

private boolean isTagPresent() {

4787

for (Object object : mObjectMap.values()) {

4788

if (object instanceof TagEndpoint) {

4789

return ((TagEndpoint) object).isPresent();

}

}

return false;

}

Suhas Suresh

5efc543

2018-04-27 15:31:02 +0530

[diff] [blame]

4794

4795

private void StopPresenceChecking() {

4796

Object[] objectValues = mObjectMap.values().toArray();

4797

for (Object object : objectValues) {

4798

if (object instanceof TagEndpoint) {

4799

TagEndpoint tag = (TagEndpoint)object;

4800

((TagEndpoint) object).stopPresenceChecking();

}

}

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4805

/**

4806

* Disconnect any target if present

4807

*/

4808

void maybeDisconnectTarget() {

4809

if (!isNfcEnabledOrShuttingDown()) {

4810

return;

4811

}

4812

Object[] objectsToDisconnect;

4813

synchronized (this) {

4814

Object[] objectValues = mObjectMap.values().toArray();

4815

// Copy the array before we clear mObjectMap,

4816

// just in case the HashMap values are backed by the same array

4817

objectsToDisconnect = Arrays.copyOf(objectValues, objectValues.length);

4818

mObjectMap.clear();

4819

}

4820

for (Object o : objectsToDisconnect) {

4821

if (DBG) Log.d(TAG, "disconnecting " + o.getClass().getName());

4822

if (o instanceof TagEndpoint) {

4823

// Disconnect from tags

4824

TagEndpoint tag = (TagEndpoint) o;

4825

tag.disconnect();

4826

} else if (o instanceof NfcDepEndpoint) {

4827

// Disconnect from P2P devices

4828

NfcDepEndpoint device = (NfcDepEndpoint) o;

4829

if (device.getMode() == NfcDepEndpoint.MODE_P2P_TARGET) {

4830

// Remote peer is target, request disconnection

4831

device.disconnect();

4832

} else {

4833

// Remote peer is initiator, we cannot disconnect

4834

// Just wait for field removal

}

}

}

}

Object findObject(int key) {

4841

synchronized (this) {

4842

Object device = mObjectMap.get(key);

4843

if (device == null) {

4844

Log.w(TAG, "Handle not found");

}

return device;

}

}

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

4850

Object findAndRemoveObject(int handle) {

4851

synchronized (this) {

4852

Object device = mObjectMap.get(handle);

4853

if (device == null) {

4854

Log.w(TAG, "Handle not found");

4855

} else {

4856

mObjectMap.remove(handle);

}

return device;

}

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4862

void registerTagObject(TagEndpoint tag) {

4863

synchronized (this) {

4864

mObjectMap.put(tag.getHandle(), tag);

}

}

void unregisterObject(int handle) {

4869

synchronized (this) {

4870

mObjectMap.remove(handle);

}

}

/**

* For use by code in this process

4876

*/

4877

public LlcpSocket createLlcpSocket(int sap, int miu, int rw, int linearBufferLength)

4878

throws LlcpException {

4879

return mDeviceHost.createLlcpSocket(sap, miu, rw, linearBufferLength);

}

/**

* For use by code in this process

4884

*/

4885

public LlcpConnectionlessSocket createLlcpConnectionLessSocket(int sap, String sn)

4886

throws LlcpException {

4887

return mDeviceHost.createLlcpConnectionlessSocket(sap, sn);

}

/**

* For use by code in this process

4892

*/

4893

public LlcpServerSocket createLlcpServerSocket(int sap, String sn, int miu, int rw,

4894

int linearBufferLength) throws LlcpException {

4895

return mDeviceHost.createLlcpServerSocket(sap, sn, miu, rw, linearBufferLength);

4896

}

4897

4898

public void sendMockNdefTag(NdefMessage msg) {

4899

sendMessage(MSG_MOCK_NDEF, msg);

4900

}

4901

4902

public void notifyRoutingTableFull()

4903

{

nxpandroid

2016-12-22 18:48:59 +0530

[diff] [blame]

4904

if(!mNxpNfcController.isGsmaCommitOffhostService()) {

4905

ComponentName prevPaymentComponent = mAidCache.getPreviousPreferredPaymentService();

4906

4907

mNxpPrefsEditor = mNxpPrefs.edit();

4908

mNxpPrefsEditor.putInt("PREF_SET_AID_ROUTING_TABLE_FULL",0x01);

4909

mNxpPrefsEditor.commit();

4910

//broadcast Aid Routing Table Full intent to the user

4911

Intent aidTableFull = new Intent();

4912

aidTableFull.putExtra(NxpConstants.EXTRA_GSMA_PREV_PAYMENT_COMPONENT,prevPaymentComponent);

4913

aidTableFull.setAction(NxpConstants.ACTION_ROUTING_TABLE_FULL);

4914

if (DBG) {

4915

Log.d(TAG, "notify aid routing table full to the user");

4916

}

4917

mContext.sendBroadcastAsUser(aidTableFull, UserHandle.CURRENT);

4918

mAidCache.setPreviousPreferredPaymentService(null);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4919

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4920

}

4921

/**

4922

* set default Aid route entry in case application does not configure this route entry

4923

*/

nxpandroid

2016-12-22 18:48:59 +0530

[diff] [blame]

4924

public void setDefaultAidRouteLoc( int routeLoc)

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4925

{

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

4926

mNxpPrefsEditor = mNxpPrefs.edit();

nxpandroid

2016-12-22 18:48:59 +0530

[diff] [blame]

4927

Log.d(TAG, "writing to preferences setDefaultAidRouteLoc :" + routeLoc);

4928

4929

int defaultAidRoute = ((mDeviceHost.getDefaultAidPowerState() & 0x1F) | (routeLoc << ROUTE_LOC_MASK));

if(routeLoc == 0x00)

{

/*

bit pos 1 = Power Off

4934

bit pos 2 = Battery Off

4935

bit pos 4 = Screen Off

4936

Set these bits to 0 because in case routeLoc = HOST it can not work on POWER_OFF, BATTERY_OFF and SCREEN_OFF*/

4937

defaultAidRoute &= 0xE9;

4938

}

4939

4940

mNxpPrefsEditor.putInt("PREF_SET_DEFAULT_ROUTE_ID", defaultAidRoute);

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

4941

mNxpPrefsEditor.commit();

4942

int defaultRoute=mNxpPrefs.getInt("PREF_SET_DEFAULT_ROUTE_ID",0xFF);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4943

Log.d(TAG, "reading preferences from user :" + defaultRoute);

4944

}

4945

4946

public int getAidRoutingTableSize ()

4947

{

4948

int aidTableSize = 0x00;

4949

aidTableSize = mDeviceHost.getAidTableSize();

return aidTableSize;

}

nxpandroid

2017-07-12 21:37:17 +0530

[diff] [blame]

4953

public void routeAids(String aid, int route, int powerState, int aidInfo) {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4954

Message msg = mHandler.obtainMessage();

4955

msg.what = MSG_ROUTE_AID;

4956

msg.arg1 = route;

4957

msg.arg2 = powerState;

nxpandroid

2017-07-12 21:37:17 +0530

[diff] [blame]

4958

Bundle aidbundle = new Bundle();

4959

aidbundle.putInt("aidinfo",aidInfo);

4960

msg.setData(aidbundle);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

4961

msg.obj = aid;

4962

mHandler.sendMessage(msg);

4963

}

4964

4965

public void unrouteAids(String aid) {

4966

sendMessage(MSG_UNROUTE_AID, aid);

4967

}

nxpandroid

a5fd662

2017-07-31 16:15:18 +0530

[diff] [blame]

4968

4969

public void routeApduPattern(String apdu, String mask ,int route, int powerState) {

4970

Message msg = mHandler.obtainMessage();

4971

msg.what = MSG_ROUTE_APDU;

4972

msg.arg1 = route;

4973

msg.arg2 = powerState;

4974

Bundle apduPatternbundle = new Bundle();

4975

apduPatternbundle.putString("apduData",apdu);

4976

apduPatternbundle.putString("apduMask",mask);

4977

msg.setData(apduPatternbundle);

4978

mHandler.sendMessage(msg);

4979

}

4980

4981

public void unrouteApduPattern(String apdu) {

4982

//sendMessage(MSG_UNROUTE_APDU, apdu);

4983

mDeviceHost.unrouteApduPattern(hexStringToBytes(apdu));

4984

}

4985

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

4986

public int getNciVersion() {

4987

return mDeviceHost.getNciVersion();

4988

}

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

4989

private byte[] getT3tIdentifierBytes(String systemCode, String nfcId2, String t3tPmm) {

4990

ByteBuffer buffer = ByteBuffer.allocate(2 + 8 + 8);

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

4991

buffer.put(hexStringToBytes(systemCode));

4992

buffer.put(hexStringToBytes(nfcId2));

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

4993

buffer.put(hexStringToBytes(t3tPmm));

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

4994

byte[] t3tIdBytes = new byte[buffer.position()];

4995

buffer.position(0);

4996

buffer.get(t3tIdBytes);

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

4997

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

return t3tIdBytes;

}

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5001

public void registerT3tIdentifier(String systemCode, String nfcId2, String t3tPmm) {

5002

Log.d(TAG, "request to register LF_T3T_IDENTIFIER");

5003

5004

byte[] t3tIdentifier = getT3tIdentifierBytes(systemCode, nfcId2, t3tPmm);

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

5005

sendMessage(MSG_REGISTER_T3T_IDENTIFIER, t3tIdentifier);

5006

}

5007

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5008

public void deregisterT3tIdentifier(String systemCode, String nfcId2, String t3tPmm) {

5009

Log.d(TAG, "request to deregister LF_T3T_IDENTIFIER");

5010

5011

byte[] t3tIdentifier = getT3tIdentifierBytes(systemCode, nfcId2, t3tPmm);

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

5012

sendMessage(MSG_DEREGISTER_T3T_IDENTIFIER, t3tIdentifier);

5013

}

5014

5015

public void clearT3tIdentifiersCache() {

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5016

Log.d(TAG, "clear T3t Identifiers Cache");

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

5017

mDeviceHost.clearT3tIdentifiersCache();

5018

}

5019

5020

public int getLfT3tMax() {

5021

return mDeviceHost.getLfT3tMax();

5022

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5023

5024

public void commitRouting() {

5025

mHandler.sendEmptyMessage(MSG_COMMIT_ROUTING);

5026

}

5027

/**

5028

* get default Aid route entry in case application does not configure this route entry

5029

*/

5030

public int GetDefaultRouteLoc()

5031

{

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

5032

int defaultRouteLoc = mNxpPrefs.getInt("PREF_SET_DEFAULT_ROUTE_ID", GetDefaultRouteEntry()) >> ROUTE_LOC_MASK;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5033

Log.d(TAG, "GetDefaultRouteLoc :" + defaultRouteLoc);

5034

return defaultRouteLoc ;

}

/**

* get default MifareDesfireRoute route entry in case application does not configure this route entry

5039

*/

5040

public int GetDefaultMifareDesfireRouteEntry()

5041

{

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5042

int routeLoc = mDeviceHost.getDefaultDesfireRoute();

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5043

int defaultMifareDesfireRoute = ((mDeviceHost.getDefaultDesfirePowerState() & 0x3F) | (routeLoc << ROUTE_LOC_MASK));

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5044

if(routeLoc == 0x00)

5045

{

nxpandroid

2016-09-16 20:21:47 +0530

[diff] [blame]

5046

/*

5047

bit pos 1 = Power Off

5048

bit pos 2 = Battery Off

5049

bit pos 4 = Screen Off

5050

Set these bits to 0 because in case routeLoc = HOST it can not work on POWER_OFF, BATTERY_OFF and SCREEN_OFF*/

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5051

defaultMifareDesfireRoute &= 0xF9;

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5052

}

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5053

if (DBG) Log.d(TAG, "defaultMifareDesfireRoute : " + defaultMifareDesfireRoute);

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5054

return defaultMifareDesfireRoute;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5055

}

5056

/**

5057

* set default Aid route entry in case application does not configure this route entry

5058

*/

5059

5060

public int GetDefaultRouteEntry()

5061

{

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5062

int routeLoc = mDeviceHost.getDefaultAidRoute();

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5063

int defaultAidRoute = ((mDeviceHost.getDefaultAidPowerState() & 0x3F) | (routeLoc << ROUTE_LOC_MASK));

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5064

if(routeLoc == 0x00)

5065

{

nxpandroid

2016-09-16 20:21:47 +0530

[diff] [blame]

5066

/*

5067

bit pos 1 = Power Off

5068

bit pos 2 = Battery Off

5069

bit pos 4 = Screen Off

5070

Set these bits to 0 because in case routeLoc = HOST it can not work on POWER_OFF, BATTERY_OFF and SCREEN_OFF*/

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5071

defaultAidRoute &= 0xF9;

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5072

}

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5073

if (DBG) Log.d(TAG, "defaultAidRoute : " + defaultAidRoute);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5074

return defaultAidRoute;

}

/**

* get default MifateCLT route entry in case application does not configure this route entry

5079

*/

5080

public int GetDefaultMifateCLTRouteEntry()

5081

{

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5082

int routeLoc = mDeviceHost.getDefaultMifareCLTRoute();

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5083

int defaultMifateCLTRoute = ((mDeviceHost.getDefaultMifareCLTPowerState() & 0x3F) | (routeLoc << ROUTE_LOC_MASK) | (TECH_TYPE_A << TECH_TYPE_MASK));

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5084

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5085

if (DBG) Log.d(TAG, "defaultMifateCLTRoute : " + defaultMifateCLTRoute);

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5086

return defaultMifateCLTRoute;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5087

}

5088

5089

public boolean setDefaultRoute(int defaultRouteEntry, int defaultProtoRouteEntry, int defaultTechRouteEntry) {

5090

boolean ret = mDeviceHost.setDefaultRoute(defaultRouteEntry, defaultProtoRouteEntry, defaultTechRouteEntry);

return ret;

}

public int getDefaultRoute() {

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

5095

return mNxpPrefs.getInt(PREF_DEFAULT_ROUTE_ID, DEFAULT_ROUTE_ID_DEFAULT);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

public void commitingFelicaRouting() {

5100

mHandler.sendEmptyMessage(MSG_COMMITINF_FELICA_ROUTING);

5101

}

5102

5103

public void commitedFelicaRouting() {

5104

mHandler.sendEmptyMessage(MSG_COMMITED_FELICA_ROUTING);

5105

}

5106

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

5107

public int getAidRoutingTableStatus() {

5108

int aidTableStatus = 0x00;

5109

aidTableStatus = mNxpPrefs.getInt("PREF_SET_AID_ROUTING_TABLE_FULL",0x00);

5110

return aidTableStatus;

5111

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5112

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5113

public void clearRouting() {

5114

mHandler.sendEmptyMessage(MSG_CLEAR_ROUTING);

5115

}

5116

5117

public boolean isVzwFeatureEnabled(){

5118

return mDeviceHost.isVzwFeatureEnabled();

5119

}

5120

5121

public boolean sendData(byte[] data) {

5122

return mDeviceHost.sendRawFrame(data);

5123

}

5124

5125

public int getDefaultSecureElement() {

5126

int[] seList = mDeviceHost.doGetSecureElementList();

5127

if ( seList == null || seList.length != 1) {

//use default value

return -1;

} else {

return seList[0];

}

}

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

5135

public void updateLastScreenState()

5136

{

5137

Log.d(TAG, "updateLastScreenState");

5138

int screen_state_mask = (mNfcUnlockManager.isLockscreenPollingEnabled()) ?

5139

(ScreenStateHelper.SCREEN_POLLING_TAG_MASK | mScreenState) : mScreenState;

5140

mDeviceHost.doSetScreenOrPowerState(screen_state_mask);

5141

}

5142

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5143

public void etsiStartConfig(int eeHandle) {

5144

Log.d(TAG, "etsiStartConfig Enter");

5145

5146

Log.d(TAG, "etsiStartConfig : etsiInitConfig");

5147

mDeviceHost.etsiInitConfig();

5148

5149

Log.d(TAG, "etsiStartConfig : disableDiscovery");

5150

mDeviceHost.disableDiscovery();

5151

5152

Log.d(TAG, "etsiStartConfig : etsiReaderConfig");

5153

mDeviceHost.etsiReaderConfig(eeHandle);

5154

5155

Log.d(TAG, "etsiStartConfig : notifyEEReaderEvent");

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

5156

mDeviceHost.notifyEEReaderEvent(ETSI_READER_START_SUCCESS);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5157

5158

Log.d(TAG, "etsiStartConfig : setEtsiReaederState");

5159

mDeviceHost.setEtsiReaederState(STATE_SE_RDR_MODE_STARTED);

5160

//broadcast SWP_READER_ACTIVATED evt

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

5161

Intent swpReaderRequestedIntent = new Intent();

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

5162

swpReaderRequestedIntent.setAction(NxpConstants.ACTION_NFC_MPOS_READER_MODE_START_SUCCESS);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5163

if (DBG) {

5164

Log.d(TAG, "SWP READER - Requested");

5165

}

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

5166

mContext.sendBroadcast(swpReaderRequestedIntent);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5167

5168

Log.d(TAG, "etsiStartConfig : enableDiscovery");

5169

mDeviceHost.enableDiscovery(mCurrentDiscoveryParameters, true);

5170

5171

Log.d(TAG, "etsiStartConfig Exit");

5172

}

5173

5174

public void etsiStopConfig(int discNtfTimeout) {

5175

Log.d(TAG, "etsiStopConfig Enter");

5176

if( mDeviceHost.getEtsiReaederState() == STATE_SE_RDR_MODE_STOP_IN_PROGRESS)

5177

{

5178

Log.d(TAG, "Attempting etsiStopConfig while STATE_SE_RDR_MODE_STOP_IN_PROGRESS. Returning..");

5179

return;

5180

}

5181

ETSI_STOP_CONFIG = true;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5182

Log.d(TAG, "etsiStopConfig : etsiInitConfig");

5183

mDeviceHost.etsiInitConfig();

5184

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

5185

Timer mTimer = new Timer();

5186

TagRemoveTaskTimer tagRemoveTask = new TagRemoveTaskTimer();

5187

mTimer.schedule(tagRemoveTask, ETSI_PRESENCE_CHECK_DELAY, ETSI_PRESENCE_CHECK_DELAY);

5188

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5189

Log.d(TAG, "etsiStopConfig : disableDiscovery");

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

5190

mDeviceHost.stopPoll(NxpConstants.ULTRA_LOW_POWER);

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

5191

mTimer.cancel();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5192

5193

if(mDeviceHost.getEtsiReaederState() == STATE_SE_RDR_MODE_STOPPED)

5194

{

5195

Log.d(TAG, "etsiStopConfig :etsi reader already Stopped. Returning..");

5196

ETSI_STOP_CONFIG = false;

5197

return;

5198

}

5199

Log.d(TAG, "etsiStopConfig : etsiResetReaderConfig");

5200

mDeviceHost.etsiResetReaderConfig();

5201

5202

Log.d(TAG, "etsiStopConfig : notifyEEReaderEvent");

5203

mDeviceHost.notifyEEReaderEvent(ETSI_READER_STOP);

5204

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

5205

Intent swpReaderDeActivatedIntent = new Intent();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5206

5207

//broadcast SWP_READER_DEACTIVATED evt

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

5208

swpReaderDeActivatedIntent

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

5209

.setAction(NxpConstants.ACTION_NFC_MPOS_READER_MODE_STOP_SUCCESS);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5210

if (DBG) {

5211

Log.d(TAG, "SWP READER - DeActivated");

5212

}

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

5213

mContext.sendBroadcast(swpReaderDeActivatedIntent);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5214

5215

Log.d(TAG, "etsiStopConfig : setEtsiReaederState");

5216

mDeviceHost.setEtsiReaederState(STATE_SE_RDR_MODE_STOPPED);

5217

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5218

ETSI_STOP_CONFIG = false;

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

5219

updateLastScreenState();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5220

5221

Log.d(TAG, "etsiStopConfig Exit");

5222

}

5223

5224

void sendMessage(int what, Object obj) {

5225

Message msg = mHandler.obtainMessage();

5226

msg.what = what;

5227

msg.obj = obj;

5228

mHandler.sendMessage(msg);

5229

}

5230

5231

final class NfcServiceHandler extends Handler {

5232

@Override

5233

public void handleMessage(Message msg) {

5234

switch (msg.what) {

5235

case MSG_ROUTE_AID: {

5236

int route = msg.arg1;

5237

int power = msg.arg2;

nxpandroid

2017-07-12 21:37:17 +0530

[diff] [blame]

5238

int aidInfo = 0x00;

5239

Bundle dataBundle = msg.getData();

5240

if (dataBundle != null)

5241

aidInfo = dataBundle.getInt("aidinfo");

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5242

String aid = (String) msg.obj;

nxpandroid

2017-07-12 21:37:17 +0530

[diff] [blame]

5243

String cuttedAid = aid;

5244

if(aid.endsWith("*")||aid.endsWith("#")) {

5245

cuttedAid = aid.substring(0, aid.length() - 1);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5246

}

nxpandroid

2017-07-12 21:37:17 +0530

[diff] [blame]

5247

mDeviceHost.routeAid(hexStringToBytes(cuttedAid), route, power, aidInfo);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5248

// Restart polling config

5249

break;

5250

}

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

5251

case MSG_REGISTER_T3T_IDENTIFIER: {

5252

Log.d(TAG, "message to register LF_T3T_IDENTIFIER");

5253

mDeviceHost.disableDiscovery();

5254

5255

byte[] t3tIdentifier = (byte[]) msg.obj;

5256

mDeviceHost.registerT3tIdentifier(t3tIdentifier);

5257

5258

NfcDiscoveryParameters params = computeDiscoveryParameters(mScreenState);

5259

boolean shouldRestart = mCurrentDiscoveryParameters.shouldEnableDiscovery();

5260

mDeviceHost.enableDiscovery(params, shouldRestart);

5261

break;

5262

}

5263

case MSG_DEREGISTER_T3T_IDENTIFIER: {

5264

Log.d(TAG, "message to deregister LF_T3T_IDENTIFIER");

5265

mDeviceHost.disableDiscovery();

5266

5267

byte[] t3tIdentifier = (byte[]) msg.obj;

5268

mDeviceHost.deregisterT3tIdentifier(t3tIdentifier);

5269

5270

NfcDiscoveryParameters params = computeDiscoveryParameters(mScreenState);

5271

boolean shouldRestart = mCurrentDiscoveryParameters.shouldEnableDiscovery();

5272

mDeviceHost.enableDiscovery(params, shouldRestart);

5273

break;

5274

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5275

case MSG_INVOKE_BEAM: {

5276

mP2pLinkManager.onManualBeamInvoke((BeamShareData)msg.obj);

5277

break;

5278

}

nxpandroid

a5fd662

2017-07-31 16:15:18 +0530

[diff] [blame]

5279

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5280

case MSG_UNROUTE_AID: {

5281

String aid = (String) msg.obj;

5282

mDeviceHost.unrouteAid(hexStringToBytes(aid));

break;

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5286

case MSG_COMMITINF_FELICA_ROUTING: {

5287

Log.e(TAG, "applyRouting -10");

5288

mIsFelicaOnHostConfiguring = true;

applyRouting(true);

break;

}

case MSG_COMMITED_FELICA_ROUTING: {

5294

Log.e(TAG, "applyRouting -11");

5295

mIsFelicaOnHostConfigured = true;

applyRouting(true);

break;

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5300

case MSG_COMMIT_ROUTING: {

5301

Log.e(TAG, "applyRouting -9");

5302

boolean commit = false;

nxpandroid

07d1cc2

2017-09-14 12:20:58 +0530

[diff] [blame]

5303

boolean enForced = false;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5304

synchronized (NfcService.this) {

5305

if (mCurrentDiscoveryParameters.shouldEnableDiscovery()) {

5306

commit = true;

nxpandroid

07d1cc2

2017-09-14 12:20:58 +0530

[diff] [blame]

5307

}else if(mAidRoutingManager.isRoutingTableUpdated()){

5308

commit = true;

5309

enForced = true;

5310

Log.d(TAG, "Routing table is updated thus needs to be committed.");

5311

}

5312

else {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5313

Log.d(TAG, "Not committing routing because discovery is disabled.");

}

}

if (commit) {

mIsRoutingTableDirty = true;

nxpandroid

07d1cc2

2017-09-14 12:20:58 +0530

[diff] [blame]

5318

applyRouting(enForced);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

break;

}

case MSG_CLEAR_ROUTING: {

5325

mDeviceHost.clearAidTable();

break;

}

case MSG_CHANGE_DEFAULT_ROUTE:

5330

Log.d(TAG, "Handler: Change default route");

5331

try{

5332

mNxpNfcAdapter.DefaultRouteSet(ROUTE_ID_HOST, true, false, false);

5333

} catch(RemoteException re) {

5334

Log.d(TAG, "NxpNci: onAidRoutingTableFull: Exception to change default route to host!");

}

break;

case MSG_MOCK_NDEF: {

5339

NdefMessage ndefMsg = (NdefMessage) msg.obj;

5340

Bundle extras = new Bundle();

5341

extras.putParcelable(Ndef.EXTRA_NDEF_MSG, ndefMsg);

5342

extras.putInt(Ndef.EXTRA_NDEF_MAXLENGTH, 0);

5343

extras.putInt(Ndef.EXTRA_NDEF_CARDSTATE, Ndef.NDEF_MODE_READ_ONLY);

5344

extras.putInt(Ndef.EXTRA_NDEF_TYPE, Ndef.TYPE_OTHER);

5345

Tag tag = Tag.createMockTag(new byte[]{0x00},

5346

new int[]{TagTechnology.NDEF},

5347

new Bundle[]{extras});

5348

Log.d(TAG, "mock NDEF tag, starting corresponding activity");

5349

Log.d(TAG, tag.toString());

5350

int dispatchStatus = mNfcDispatcher.dispatchTag(tag);

5351

if (dispatchStatus == NfcDispatcher.DISPATCH_SUCCESS) {

5352

playSound(SOUND_END);

5353

} else if (dispatchStatus == NfcDispatcher.DISPATCH_FAIL) {

5354

playSound(SOUND_ERROR);

}

break;

}

case MSG_SE_DELIVER_INTENT: {

5360

Log.d(TAG, "SE DELIVER INTENT");

5361

Intent seIntent = (Intent) msg.obj;

5362

5363

String action = seIntent.getAction();

5364

if (action.equals("com.gsma.services.nfc.action.TRANSACTION_EVENT")) {

5365

byte[] byteAid = seIntent.getByteArrayExtra("com.android.nfc_extras.extra.AID");

5366

byte[] data = seIntent.getByteArrayExtra("com.android.nfc_extras.extra.DATA");

5367

String seName = seIntent.getStringExtra("com.android.nfc_extras.extra.SE_NAME");

5368

StringBuffer strAid = new StringBuffer();

5369

for (int i = 0; i < byteAid.length; i++) {

5370

String hex = Integer.toHexString(0xFF & byteAid[i]);

5371

if (hex.length() == 1)

strAid.append('0');

strAid.append(hex);

}

Intent gsmaIntent = new Intent();

5376

gsmaIntent.setAction("com.gsma.services.nfc.action.TRANSACTION_EVENT");

5377

if (byteAid != null)

5378

gsmaIntent.putExtra("com.gsma.services.nfc.extra.AID", byteAid);

5379

if (data != null)

5380

gsmaIntent.putExtra("com.gsma.services.nfc.extra.DATA", data);

5381

5382

//"nfc://secure:0/<seName>/<strAid>"

5383

String url = new String ("nfc://secure:0/" + seName + "/" + strAid);

5384

gsmaIntent.setData(Uri.parse(url));

5385

gsmaIntent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);

5386

gsmaIntent.setPackage(seIntent.getPackage());

5387

5388

Boolean receptionMode = mNxpNfcController.mMultiReceptionMap.get(seName);

5389

if (receptionMode == null)

5390

receptionMode = defaultTransactionEventReceptionMode;

5391

5392

if (receptionMode == multiReceptionMode) {

5393

// if multicast reception for GSMA

5394

mContext.sendBroadcast(gsmaIntent);

5395

} else {

5396

// if unicast reception for GSMA

5397

try {

5398

if (mIsSentUnicastReception == false) {

5399

//start gsma

5400

gsmaIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

5401

mContext.startActivity(gsmaIntent);

5402

mIsSentUnicastReception = true;

5403

}

5404

} catch (Exception e) {

5405

if (DBG) Log.d(TAG, "Exception: " + e.getMessage());

}

}

} else {

mContext.sendBroadcast(seIntent);

}

break;

}

case MSG_NDEF_TAG:

if (DBG) Log.d(TAG, "Tag detected, notifying applications");

Suhas Suresh

31963a0

2018-04-25 12:14:23 +0530

[diff] [blame]

5416

mPowerManager.userActivity(SystemClock.uptimeMillis(),

5417

PowerManager.USER_ACTIVITY_EVENT_OTHER, 0);

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5418

mNumTagsDetected.incrementAndGet();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5419

TagEndpoint tag = (TagEndpoint) msg.obj;

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5420

byte[] debounceTagUid;

5421

int debounceTagMs;

5422

ITagRemovedCallback debounceTagRemovedCallback;

5423

synchronized (NfcService.this) {

5424

debounceTagUid = mDebounceTagUid;

5425

debounceTagMs = mDebounceTagDebounceMs;

5426

debounceTagRemovedCallback = mDebounceTagRemovedCallback;

5427

}

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5428

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5429

ReaderModeParams readerParams = null;

5430

int presenceCheckDelay = DEFAULT_PRESENCE_CHECK_DELAY;

5431

DeviceHost.TagDisconnectedCallback callback =

5432

new DeviceHost.TagDisconnectedCallback() {

5433

@Override

5434

public void onTagDisconnected(long handle) {

nxpandroid

03323c8

2017-09-14 11:13:16 +0530

[diff] [blame]

5435

if(nci_version != NCI_VERSION_2_0) {

5436

applyRouting(false);

5437

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5438

}

5439

};

5440

synchronized (NfcService.this) {

5441

readerParams = mReaderModeParams;

5442

}

5443

if (readerParams != null) {

5444

presenceCheckDelay = readerParams.presenceCheckDelay;

5445

if ((readerParams.flags & NfcAdapter.FLAG_READER_SKIP_NDEF_CHECK) != 0) {

5446

if (DBG) Log.d(TAG, "Skipping NDEF detection in reader mode");

5447

tag.startPresenceChecking(presenceCheckDelay, callback);

5448

dispatchTagEndpoint(tag, readerParams);

break;

}

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5453

if (tag.getConnectedTechnology() == TagTechnology.NFC_BARCODE) {

5454

// When these tags start containing NDEF, they will require

5455

// the stack to deal with them in a different way, since

5456

// they are activated only really shortly.

5457

// For now, don't consider NDEF on these.

5458

if (DBG) Log.d(TAG, "Skipping NDEF detection for NFC Barcode");

5459

tag.startPresenceChecking(presenceCheckDelay, callback);

5460

dispatchTagEndpoint(tag, readerParams);

5461

break;

5462

}

5463

NdefMessage ndefMsg = tag.findAndReadNdef();

5464

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5465

if (ndefMsg == null) {

5466

// First try to see if this was a bad tag read

5467

if (!tag.reconnect()) {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5468

tag.disconnect();

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5469

break;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5470

}

5471

}

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5472

5473

if (debounceTagUid != null) {

5474

// If we're debouncing and the UID or the NDEF message of the tag match,

5475

// don't dispatch but drop it.

5476

if (Arrays.equals(debounceTagUid, tag.getUid()) ||

5477

(ndefMsg != null && ndefMsg.equals(mLastReadNdefMessage))) {

5478

mHandler.removeMessages(MSG_TAG_DEBOUNCE);

5479

mHandler.sendEmptyMessageDelayed(MSG_TAG_DEBOUNCE, debounceTagMs);

tag.disconnect();

return;

} else {

synchronized (NfcService.this) {

5484

mDebounceTagUid = null;

5485

mDebounceTagRemovedCallback = null;

Nikhil Chhabra

1b2368f

2018-01-09 18:34:21 +0530

[diff] [blame]

5486

mDebounceTagNativeHandle = INVALID_NATIVE_HANDLE;

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5487

}

5488

if (debounceTagRemovedCallback != null) {

5489

try {

5490

debounceTagRemovedCallback.onTagRemoved();

5491

} catch (RemoteException e) {

// Ignore

}

}

}

}

mLastReadNdefMessage = ndefMsg;

5499

5500

tag.startPresenceChecking(presenceCheckDelay, callback);

5501

dispatchTagEndpoint(tag, readerParams);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5502

break;

5503

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5504

case MSG_CONNECTIVITY_EVENT:

5505

if (DBG) {

5506

Log.d(TAG, "SE EVENT CONNECTIVITY");

5507

}

5508

Integer evtSrcInfo = (Integer) msg.obj;

5509

Log.d(TAG, "Event source " + evtSrcInfo);

5510

String evtSrc = "";

5511

if(evtSrcInfo == UICC_ID_TYPE) {

5512

evtSrc = NxpConstants.UICC_ID;

nxpandroid

2016-08-01 19:11:04 +0530

[diff] [blame]

5513

} else if(evtSrcInfo == UICC2_ID_TYPE) {

5514

evtSrc = NxpConstants.UICC2_ID;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5515

} else if(evtSrcInfo == SMART_MX_ID_TYPE) {

5516

evtSrc = NxpConstants.SMART_MX_ID;

5517

}

5518

5519

Intent eventConnectivityIntent = new Intent();

5520

eventConnectivityIntent.setAction(NxpConstants.ACTION_CONNECTIVITY_EVENT_DETECTED);

5521

eventConnectivityIntent.putExtra(NxpConstants.EXTRA_SOURCE, evtSrc);

5522

if (DBG) {

5523

Log.d(TAG, "Broadcasting Intent");

5524

}

5525

mContext.sendBroadcast(eventConnectivityIntent, NfcPermissions.NFC_PERMISSION);

5526

break;

5527

5528

case MSG_EMVCO_MULTI_CARD_DETECTED_EVENT:

5529

if (DBG) {

5530

Log.d(TAG, "EMVCO MULTI CARD DETECTED EVENT");

5531

}

5532

5533

Intent eventEmvcoMultiCardIntent = new Intent();

5534

eventEmvcoMultiCardIntent.setAction(ACTION_EMVCO_MULTIPLE_CARD_DETECTED);

5535

if (DBG) {

5536

Log.d(TAG, "Broadcasting Intent");

5537

}

5538

mContext.sendBroadcast(eventEmvcoMultiCardIntent, NFC_PERM);

5539

break;

5540

5541

case MSG_SE_EMV_CARD_REMOVAL:

5542

if (DBG) Log.d(TAG, "Card Removal message");

5543

/* Send broadcast */

5544

Intent cardRemovalIntent = new Intent();

5545

cardRemovalIntent.setAction(ACTION_EMV_CARD_REMOVAL);

5546

if (DBG) Log.d(TAG, "Broadcasting " + ACTION_EMV_CARD_REMOVAL);

5547

sendSeBroadcast(cardRemovalIntent);

5548

break;

5549

5550

case MSG_SE_APDU_RECEIVED:

5551

if (DBG) Log.d(TAG, "APDU Received message");

5552

byte[] apduBytes = (byte[]) msg.obj;

5553

/* Send broadcast */

5554

Intent apduReceivedIntent = new Intent();

5555

apduReceivedIntent.setAction(ACTION_APDU_RECEIVED);

5556

if (apduBytes != null && apduBytes.length > 0) {

5557

apduReceivedIntent.putExtra(EXTRA_APDU_BYTES, apduBytes);

5558

}

5559

if (DBG) Log.d(TAG, "Broadcasting " + ACTION_APDU_RECEIVED);

5560

sendSeBroadcast(apduReceivedIntent);

5561

break;

5562

5563

case MSG_SE_MIFARE_ACCESS:

5564

if (DBG) Log.d(TAG, "MIFARE access message");

5565

/* Send broadcast */

5566

byte[] mifareCmd = (byte[]) msg.obj;

5567

Intent mifareAccessIntent = new Intent();

5568

mifareAccessIntent.setAction(ACTION_MIFARE_ACCESS_DETECTED);

5569

if (mifareCmd != null && mifareCmd.length > 1) {

5570

int mifareBlock = mifareCmd[1] & 0xff;

5571

if (DBG) Log.d(TAG, "Mifare Block=" + mifareBlock);

5572

mifareAccessIntent.putExtra(EXTRA_MIFARE_BLOCK, mifareBlock);

5573

}

5574

if (DBG) Log.d(TAG, "Broadcasting " + ACTION_MIFARE_ACCESS_DETECTED);

5575

sendSeBroadcast(mifareAccessIntent);

5576

break;

5577

5578

case MSG_LLCP_LINK_ACTIVATION:

Suhas Suresh

31963a0

2018-04-25 12:14:23 +0530

[diff] [blame]

5579

mPowerManager.userActivity(SystemClock.uptimeMillis(),

5580

PowerManager.USER_ACTIVITY_EVENT_OTHER, 0);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5581

if (mIsDebugBuild) {

5582

Intent actIntent = new Intent(ACTION_LLCP_UP);

5583

mContext.sendBroadcast(actIntent);

5584

}

5585

llcpActivated((NfcDepEndpoint) msg.obj);

5586

break;

5587

5588

case MSG_LLCP_LINK_DEACTIVATED:

5589

if (mIsDebugBuild) {

5590

Intent deactIntent = new Intent(ACTION_LLCP_DOWN);

5591

mContext.sendBroadcast(deactIntent);

5592

}

5593

NfcDepEndpoint device = (NfcDepEndpoint) msg.obj;

5594

boolean needsDisconnect = false;

5595

5596

Log.d(TAG, "LLCP Link Deactivated message. Restart polling loop.");

5597

synchronized (NfcService.this) {

5598

/* Check if the device has been already unregistered */

5599

if (mObjectMap.remove(device.getHandle()) != null) {

5600

/* Disconnect if we are initiator */

5601

if (device.getMode() == NfcDepEndpoint.MODE_P2P_TARGET) {

5602

if (DBG) Log.d(TAG, "disconnecting from target");

5603

needsDisconnect = true;

5604

} else {

5605

if (DBG) Log.d(TAG, "not disconnecting from initiator");

}

}

}

if (needsDisconnect) {

5610

device.disconnect(); // restarts polling loop

5611

}

5612

5613

mP2pLinkManager.onLlcpDeactivated();

5614

break;

5615

case MSG_LLCP_LINK_FIRST_PACKET:

5616

mP2pLinkManager.onLlcpFirstPacketReceived();

5617

break;

5618

case MSG_TARGET_DESELECTED:

5619

/* Broadcast Intent Target Deselected */

5620

if (DBG) Log.d(TAG, "Target Deselected");

5621

Intent intent = new Intent();

5622

intent.setAction(NativeNfcManager.INTERNAL_TARGET_DESELECTED_ACTION);

5623

if (DBG) Log.d(TAG, "Broadcasting Intent");

5624

mContext.sendOrderedBroadcast(intent, NfcPermissions.NFC_PERMISSION);

5625

break;

5626

5627

case MSG_SE_FIELD_ACTIVATED: {

5628

if (DBG) Log.d(TAG, "SE FIELD ACTIVATED");

5629

Intent eventFieldOnIntent = new Intent();

5630

eventFieldOnIntent.setAction(ACTION_RF_FIELD_ON_DETECTED);

5631

sendSeBroadcast(eventFieldOnIntent);

5632

break;

5633

}

5634

case MSG_RESUME_POLLING:

5635

mNfcAdapter.resumePolling();

5636

break;

5637

5638

case MSG_SE_FIELD_DEACTIVATED: {

5639

if (DBG) Log.d(TAG, "SE FIELD DEACTIVATED");

5640

Intent eventFieldOffIntent = new Intent();

5641

eventFieldOffIntent.setAction(ACTION_RF_FIELD_OFF_DETECTED);

5642

sendSeBroadcast(eventFieldOffIntent);

break;

}

case MSG_SE_LISTEN_ACTIVATED: {

5647

if (DBG) Log.d(TAG, "SE LISTEN MODE ACTIVATED");

5648

Intent listenModeActivated = new Intent();

5649

listenModeActivated.setAction(ACTION_SE_LISTEN_ACTIVATED);

5650

sendSeBroadcast(listenModeActivated);

break;

}

case MSG_SE_LISTEN_DEACTIVATED: {

5655

if (DBG) Log.d(TAG, "SE LISTEN MODE DEACTIVATED");

5656

Intent listenModeDeactivated = new Intent();

5657

listenModeDeactivated.setAction(ACTION_SE_LISTEN_DEACTIVATED);

5658

sendSeBroadcast(listenModeDeactivated);

break;

}

case MSG_SWP_READER_REQUESTED:

5663

5664

/* Send broadcast ordered */

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5665

Intent swpReaderRequestedIntent = new Intent();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5666

ArrayList<Integer> techList = (ArrayList<Integer>) msg.obj;

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5667

Integer[] techs = techList.toArray(new Integer[techList.size()]);

5668

swpReaderRequestedIntent

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

5669

.setAction(NxpConstants.ACTION_NFC_MPOS_READER_MODE_START_SUCCESS);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5670

if (DBG) {

5671

Log.d(TAG, "SWP READER - Requested");

5672

}

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5673

mContext.sendBroadcast(swpReaderRequestedIntent);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5674

break;

5675

5676

case MSG_SWP_READER_REQUESTED_FAIL:

5677

5678

/* Send broadcast ordered */

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5679

Intent swpReaderRequestedFailIntent = new Intent();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5680

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5681

swpReaderRequestedFailIntent

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

5682

.setAction(NxpConstants.ACTION_NFC_MPOS_READER_MODE_START_FAIL);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5683

if (DBG) {

5684

Log.d(TAG, "SWP READER - Requested Fail");

5685

}

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5686

mContext.sendBroadcast(swpReaderRequestedFailIntent);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5687

break;

5688

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5689

case MSG_ETSI_START_CONFIG:

5690

{

5691

Log.d(TAG, "NfcServiceHandler - MSG_ETSI_START_CONFIG");

5692

ArrayList<Integer> configList = (ArrayList<Integer>) msg.obj;

5693

int eeHandle;

5694

if(configList.contains(0x402))

{

eeHandle = 0x402;

}

else{

eeHandle = 0x4C0;

}

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

5701

synchronized (NfcService.this) {

5702

etsiStartConfig(eeHandle);

5703

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

break;

case MSG_ETSI_STOP_CONFIG:

5708

5709

Log.d(TAG, "NfcServiceHandler - MSG_ETSI_STOP_CONFIG");

5710

5711

etsiStopConfig((int)msg.obj);

5712

break;

5713

5714

case MSG_ETSI_SWP_TIMEOUT:

5715

5716

Log.d(TAG, "NfcServiceHandler - MSG_ETSI_SWP_TIMEOUT");

5717

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

5718

/* Send broadcast ordered */

5719

Intent swpReaderTimeoutIntent = new Intent();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5720

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

5721

swpReaderTimeoutIntent

5722

.setAction(NxpConstants.ACTION_NFC_MPOS_READER_MODE_TIMEOUT);

5723

if (DBG) {

5724

Log.d(TAG, "SWP READER - Timeout");

5725

}

5726

mContext.sendBroadcast(swpReaderTimeoutIntent);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5727

break;

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

5728

5729

case MSG_SWP_READER_RESTART:

5730

5731

Log.d(TAG, "NfcServiceHandler - MSG_SWP_READER_RESTART");

5732

5733

/* Send broadcast ordered */

5734

Intent swpReaderRestartIntent = new Intent();

5735

5736

swpReaderRestartIntent

5737

.setAction(NxpConstants.ACTION_NFC_MPOS_READER_MODE_RESTART);

5738

if (DBG) {

5739

Log.d(TAG, "SWP READER - RESTART");

5740

}

5741

mContext.sendBroadcast(swpReaderRestartIntent);

5742

break;

5743

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

5744

case MSG_APPLY_SCREEN_STATE:

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5745

5746

mScreenState = (int)msg.obj;

Nikhil Chhabra

20be8d9

2018-01-09 18:32:58 +0530

[diff] [blame]

5747

5748

// If NFC is turning off, we shouldn't need any changes here

5749

synchronized (NfcService.this) {

5750

if (mState == NfcAdapter.STATE_TURNING_OFF)

return;

}

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

5754

int screen_state_mask = (mNfcUnlockManager.isLockscreenPollingEnabled()) ?

5755

(ScreenStateHelper.SCREEN_POLLING_TAG_MASK | mScreenState) : mScreenState;

Suhas Suresh

d8a71d2

2017-11-06 18:48:14 +0530

[diff] [blame]

5756

mDeviceHost.doSetScreenOrPowerState(screen_state_mask);

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

5757

Bhupendra Pawar

e1c7ede

2018-02-26 11:51:32 +0530

[diff] [blame]

5758

if(nci_version != NCI_VERSION_2_0) {

5759

applyRouting(false);

5760

} else if(mScreenState == ScreenStateHelper.SCREEN_STATE_ON_UNLOCKED

Suhas Suresh

d8a71d2

2017-11-06 18:48:14 +0530

[diff] [blame]

5761

|| mNfcUnlockManager.isLockscreenPollingEnabled()) {

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

5762

applyRouting(false);

Suhas Suresh

d8a71d2

2017-11-06 18:48:14 +0530

[diff] [blame]

5763

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5764

break;

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5765

case MSG_TAG_DEBOUNCE:

5766

// Didn't see the tag again, tag is gone

5767

ITagRemovedCallback tagRemovedCallback;

5768

synchronized (NfcService.this) {

5769

mDebounceTagUid = null;

5770

tagRemovedCallback = mDebounceTagRemovedCallback;

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5771

mDebounceTagRemovedCallback = null;

Nikhil Chhabra

1b2368f

2018-01-09 18:34:21 +0530

[diff] [blame]

5772

mDebounceTagNativeHandle = INVALID_NATIVE_HANDLE;

nxpandroid

2016-08-25 20:27:46 +0530

[diff] [blame]

5773

}

5774

if (tagRemovedCallback != null) {

5775

try {

5776

tagRemovedCallback.onTagRemoved();

5777

} catch (RemoteException e) {

// Ignore

}

}

break;

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

5782

case MSG_RESTART_WATCHDOG:

5783

int enable = msg.arg1;

5784

disableInternalwatchDog.cancel();

5785

try{

5786

disableInternalwatchDog.join();

5787

} catch (java.lang.InterruptedException e) {

5788

}

5789

disableInternalwatchDog = new WatchDogThread("disableInternal", ROUTING_WATCHDOG_MS);

5790

Log.d(TAG, "New Watchdog: WatchDog Thread ID is "+ disableInternalwatchDog.getId());

5791

disableInternalwatchDog.start();

5792

break;

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

5793

case MSG_UPDATE_STATS:

5794

if (mNumTagsDetected.get() > 0) {

5795

MetricsLogger.count(mContext, TRON_NFC_TAG, mNumTagsDetected.get());

5796

mNumTagsDetected.set(0);

5797

}

5798

if (mNumHceDetected.get() > 0) {

5799

MetricsLogger.count(mContext, TRON_NFC_CE, mNumHceDetected.get());

5800

mNumHceDetected.set(0);

5801

}

5802

if (mNumP2pDetected.get() > 0) {

5803

MetricsLogger.count(mContext, TRON_NFC_P2P, mNumP2pDetected.get());

5804

mNumP2pDetected.set(0);

5805

}

5806

removeMessages(MSG_UPDATE_STATS);

5807

sendEmptyMessageDelayed(MSG_UPDATE_STATS, STATS_UPDATE_INTERVAL_MS);

5808

break;

nxpandroid

a5fd662

2017-07-31 16:15:18 +0530

[diff] [blame]

5809

5810

case MSG_ROUTE_APDU:{

5811

int route = msg.arg1;

5812

int power = msg.arg2;

5813

String apduData = null;

5814

String apduMask = null;

5815

Bundle dataBundle = msg.getData();

5816

if (dataBundle != null) {

5817

apduData = dataBundle.getString("apduData");

5818

apduMask = dataBundle.getString("apduMask");

5819

}

5820

// Send the APDU

5821

if(apduData != null && dataBundle != null)

5822

mDeviceHost.routeApduPattern(route, power, hexStringToBytes(apduData) ,hexStringToBytes(apduMask));

5823

break;

5824

}

5825

case MSG_UNROUTE_APDU: {

5826

String apdu = (String) msg.obj;

5827

mDeviceHost.unrouteApduPattern(hexStringToBytes(apdu));

5828

break;

5829

}

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

5830

case MSG_TRANSACTION_EVENT:

5831

if (mCardEmulationManager != null) {

5832

mCardEmulationManager.onOffHostAidSelected();

5833

}

5834

byte[][] data = (byte[][]) msg.obj;

Suhas Suresh

2018-05-15 17:45:06 +0530

[diff] [blame]

5835

sendOffHostTransactionEvent(data[0], data[1], data[2]);

5836

break;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5837

default:

5838

Log.e(TAG, "Unknown message received");

break;

}

}

Suhas Suresh

2018-05-15 17:45:06 +0530

[diff] [blame]

5843

private void sendOffHostTransactionEvent(byte[] aid, byte[] data, byte[] readerByteArray) {

Suhas Suresh

3824995

2018-05-18 00:03:00 +0530

[diff] [blame^]

5844

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

5845

if (mSEService == null || mNfcEventInstalledPackages.isEmpty()) {

5846

return;

5847

}

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

5848

try {

Suhas Suresh

2018-05-15 17:45:06 +0530

[diff] [blame]

5849

String reader = new String(readerByteArray, "UTF-8");

5850

String[] installedPackages = new String[mNfcEventInstalledPackages.size()];

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

5851

boolean[] nfcAccess = mSEService.isNFCEventAllowed(reader, aid,

5852

mNfcEventInstalledPackages.toArray(installedPackages));

5853

if (nfcAccess == null) {

5854

return;

5855

}

5856

ArrayList<String> packages = new ArrayList<String>();

Suhas Suresh

2018-05-09 15:48:37 +0530

[diff] [blame]

5857

Intent intent = new Intent(NxpConstants.ACTION_TRANSACTION_DETECTED);

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

5858

intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);

Suhas Suresh

2018-05-15 17:45:06 +0530

[diff] [blame]

5859

intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

Suhas Suresh

2018-05-09 15:48:37 +0530

[diff] [blame]

5860

intent.putExtra(NxpConstants.EXTRA_AID, aid);

5861

intent.putExtra(NxpConstants.EXTRA_DATA, data);

5862

intent.putExtra(NxpConstants.EXTRA_SE_NAME, reader);

Suhas Suresh

2018-05-15 17:45:06 +0530

[diff] [blame]

5863

StringBuilder aidString = new StringBuilder(aid.length);

5864

for (byte b : aid) {

5865

aidString.append(String.format("%02X", b));

5866

}

5867

String url = new String ("nfc://secure:0/" + reader + "/" + aidString.toString());

5868

intent.setData(Uri.parse(url));

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

5869

for (int i = 0; i < nfcAccess.length; i++) {

5870

if (nfcAccess[i]) {

Suhas Suresh

140f7ac

2018-05-15 14:59:11 +0530

[diff] [blame]

5871

intent.setPackage(mNfcEventInstalledPackages.get(i));

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

5872

mContext.sendBroadcast(intent);

5873

}

5874

}

5875

} catch (RemoteException e) {

5876

Log.e(TAG, "Error in isNFCEventAllowed() " + e);

Suhas Suresh

2018-05-15 17:45:06 +0530

[diff] [blame]

5877

} catch (UnsupportedEncodingException e) {

5878

Log.e(TAG, "Incorrect format for Secure Element name" + e);

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

}

}

/* Returns the list of packages that have access to NFC Events on any SE */

5883

private ArrayList<String> getSEAccessAllowedPackages() {

5884

if (mSEService == null || mNfcEventInstalledPackages.isEmpty()) {

5885

return null;

5886

}

5887

String[] readers = null;

5888

try {

5889

readers = mSEService.getReaders();

5890

} catch (RemoteException e) {

5891

Log.e(TAG, "Error in getReaders() " + e);

return null;

}

if (readers == null || readers.length == 0) {

5896

return null;

5897

}

5898

boolean[] nfcAccessFinal = null;

5899

String[] installedPackages = new String[mNfcEventInstalledPackages.size()];

5900

for (String reader : readers) {

5901

try {

5902

boolean[] accessList = mSEService.isNFCEventAllowed(reader, null,

5903

mNfcEventInstalledPackages.toArray(installedPackages));

5904

if (accessList == null) {

5905

continue;

5906

}

5907

if (nfcAccessFinal == null) {

5908

nfcAccessFinal = accessList;

5909

}

5910

for (int i = 0; i < accessList.length; i++) {

5911

if (accessList[i]) {

5912

nfcAccessFinal[i] = true;

5913

}

5914

}

5915

} catch (RemoteException e) {

5916

Log.e(TAG, "Error in isNFCEventAllowed() " + e);

5917

}

5918

}

5919

if (nfcAccessFinal == null) {

5920

return null;

5921

}

5922

ArrayList<String> packages = new ArrayList<String>();

5923

for (int i = 0; i < nfcAccessFinal.length; i++) {

5924

if (nfcAccessFinal[i]) {

Suhas Suresh

140f7ac

2018-05-15 14:59:11 +0530

[diff] [blame]

5925

packages.add(mNfcEventInstalledPackages.get(i));

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

}

}

return packages;

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5931

private void sendSeBroadcast(Intent intent) {

5932

intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);

5933

// Resume app switches so the receivers can start activites without delay

5934

mNfcDispatcher.resumeAppSwitches();

nxpandroid

a51b5bd

2017-04-10 18:28:21 +0530

[diff] [blame]

5935

Log.d(TAG, "NFCINTENT sendNfcEeAccessProtectedBroadcast");

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5936

synchronized(this) {

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

5937

ArrayList<String> SEPackages = getSEAccessAllowedPackages();

5938

if (SEPackages!= null && !SEPackages.isEmpty()) {

5939

for (String packageName : SEPackages) {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5940

intent.setPackage(packageName);

nxpandroid

a51b5bd

2017-04-10 18:28:21 +0530

[diff] [blame]

5941

Log.d(TAG, "NFCINTENT SENT TO PACKAGE" + packageName);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5942

mContext.sendBroadcast(intent);

5943

}

Suhas Suresh

2018-04-27 17:17:22 +0530

[diff] [blame]

5944

}

Suhas Suresh

140f7ac

2018-05-15 14:59:11 +0530

[diff] [blame]

5945

PackageManager pm = mContext.getPackageManager();

5946

for (String packageName : mNfcEventInstalledPackages) {

5947

try {

5948

PackageInfo info = pm.getPackageInfo(packageName, 0);

5949

if (SEPackages != null && SEPackages.contains(packageName)) {

5950

continue;

5951

}

5952

if (info.applicationInfo != null &&

5953

((info.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0 ||

5954

(info.applicationInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0)) {

5955

intent.setPackage(packageName);

5956

mContext.sendBroadcast(intent);

5957

}

5958

} catch (Exception e) {

5959

Log.e(TAG, "Exception in getPackageInfo " + e);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

}

}

}

private void sendMultiEvtBroadcast(Intent intent) {

5966

5967

ArrayList<String> packageList = mNxpNfcController.getEnabledMultiEvtsPackageList();

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

5968

ComponentName unicastComponent = null;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5969

if(packageList.size() == 0) {

5970

Log.d(TAG, "No packages to send broadcast.");

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

5971

unicastComponent = mNxpNfcController.getUnicastPackage();

5972

if(unicastComponent != null)

5973

{

5974

intent.setComponent(unicastComponent);

5975

try {

5976

//start gsma

5977

Log.d(TAG, "Starting activity uincast Pkg"+unicastComponent.flattenToString());

5978

intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);

5979

intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

5980

if(mContext.getPackageManager().resolveActivity(intent, 0) != null)

5981

{

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

5982

mContext.startActivityAsUser(intent, UserHandle.CURRENT);

nxpandroid

2016-01-14 21:12:17 +0530

[diff] [blame]

5983

} else {

5984

Log.d(TAG, "Intent not resolved");

5985

}

5986

} catch (Exception e) {

5987

if (DBG) Log.d(TAG, "Exception: " + e.getMessage());

5988

}

5989

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5990

return;

5991

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

5992

for(int i=0; i<packageList.size(); i++) {

5993

Log.d(TAG,"MultiEvt Enabled Application packageName: " + packageList.get(i));

5994

intent.setPackage(packageList.get(i));

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

5995

mContext.sendBroadcastAsUser(intent, UserHandle.CURRENT,

5996

NxpConstants.PERMISSIONS_TRANSACTION_EVENT);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

}

private boolean llcpActivated(NfcDepEndpoint device) {

6001

Log.d(TAG, "LLCP Activation message");

6002

6003

if (device.getMode() == NfcDepEndpoint.MODE_P2P_TARGET) {

6004

if (DBG) Log.d(TAG, "NativeP2pDevice.MODE_P2P_TARGET");

6005

if (device.connect()) {

6006

/* Check LLCP compliance */

6007

if (mDeviceHost.doCheckLlcp()) {

6008

/* Activate LLCP Link */

6009

if (mDeviceHost.doActivateLlcp()) {

6010

if (DBG) Log.d(TAG, "Initiator Activate LLCP OK");

6011

synchronized (NfcService.this) {

6012

// Register P2P device

6013

mObjectMap.put(device.getHandle(), device);

6014

}

nxpandroid

1153eb3

2015-11-06 18:46:58 +0530

[diff] [blame]

6015

mP2pLinkManager.onLlcpActivated(device.getLlcpVersion());

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6016

return true;

6017

} else {

6018

/* should not happen */

6019

Log.w(TAG, "Initiator LLCP activation failed. Disconnect.");

device.disconnect();

}

} else {

if (DBG) Log.d(TAG, "Remote Target does not support LLCP. Disconnect.");

device.disconnect();

}

} else {

if (DBG) Log.d(TAG, "Cannot connect remote Target. Polling loop restarted.");

6028

/*

6029

* The polling loop should have been restarted in failing

* doConnect

*/

}

} else if (device.getMode() == NfcDepEndpoint.MODE_P2P_INITIATOR) {

6034

if (DBG) Log.d(TAG, "NativeP2pDevice.MODE_P2P_INITIATOR");

6035

/* Check LLCP compliancy */

6036

if (mDeviceHost.doCheckLlcp()) {

6037

/* Activate LLCP Link */

6038

if (mDeviceHost.doActivateLlcp()) {

6039

if (DBG) Log.d(TAG, "Target Activate LLCP OK");

6040

synchronized (NfcService.this) {

6041

// Register P2P device

6042

mObjectMap.put(device.getHandle(), device);

6043

}

nxpandroid

1153eb3

2015-11-06 18:46:58 +0530

[diff] [blame]

6044

mP2pLinkManager.onLlcpActivated(device.getLlcpVersion());

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

return true;

}

} else {

Log.w(TAG, "checkLlcp failed");

}

}

return false;

}

private void dispatchTagEndpoint(TagEndpoint tagEndpoint, ReaderModeParams readerParams) {

6056

Tag tag = new Tag(tagEndpoint.getUid(), tagEndpoint.getTechList(),

6057

tagEndpoint.getTechExtras(), tagEndpoint.getHandle(), mNfcTagService);

6058

registerTagObject(tagEndpoint);

6059

if (readerParams != null) {

6060

try {

6061

if ((readerParams.flags & NfcAdapter.FLAG_READER_NO_PLATFORM_SOUNDS) == 0) {

Suhas Suresh

6e05ee0

2018-04-25 12:19:35 +0530

[diff] [blame]

6062

mVibrator.vibrate(mVibrationEffect);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6063

playSound(SOUND_END);

6064

}

6065

if (readerParams.callback != null) {

6066

readerParams.callback.onTagDiscovered(tag);

6067

return;

6068

} else {

6069

// Follow normal dispatch below

6070

}

6071

} catch (RemoteException e) {

6072

Log.e(TAG, "Reader mode remote has died, falling back.", e);

6073

// Intentional fall-through

6074

} catch (Exception e) {

6075

// Catch any other exception

6076

Log.e(TAG, "App exception, not dispatching.", e);

return;

}

}

int dispatchResult = mNfcDispatcher.dispatchTag(tag);

6081

if (dispatchResult == NfcDispatcher.DISPATCH_FAIL) {

6082

unregisterObject(tagEndpoint.getHandle());

6083

playSound(SOUND_ERROR);

6084

} else if (dispatchResult == NfcDispatcher.DISPATCH_SUCCESS) {

Suhas Suresh

6e05ee0

2018-04-25 12:19:35 +0530

[diff] [blame]

6085

mVibrator.vibrate(mVibrationEffect);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6086

playSound(SOUND_END);

}

}

}

private NfcServiceHandler mHandler = new NfcServiceHandler();

6092

6093

class ApplyRoutingTask extends AsyncTask<Integer, Void, Void> {

6094

@Override

6095

protected Void doInBackground(Integer... params) {

6096

synchronized (NfcService.this) {

6097

if (params == null || params.length != 1) {

6098

// force apply current routing

6099

Log.e(TAG, "applyRouting -1");

applyRouting(true);

return null;

}

mScreenState = params[0].intValue();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6104

mRoutingWakeLock.acquire();

6105

try {

6106

Log.e(TAG, "applyRouting -2");

6107

applyRouting(false);

6108

} finally {

6109

mRoutingWakeLock.release();

}

return null;

}

}

}

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

6116

class EtsiStopConfigTask extends AsyncTask<Integer, Void, Void> {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6117

@Override

6118

protected Void doInBackground(Integer... params) {

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

6119

synchronized (NfcService.this) {

6120

etsiStopConfig(params[0].intValue());

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6121

return null;

Pratap Reddy

2018-03-27 16:51:59 +0530

[diff] [blame]

}

}

}

class TagRemoveTaskTimer extends TimerTask {

6127

public void run()

6128

{

6129

Intent swpReaderTagRemoveIntent = new Intent();

6130

swpReaderTagRemoveIntent.setAction(NxpConstants.ACTION_NFC_MPOS_READER_MODE_REMOVE_CARD);

6131

if (DBG) {

6132

Log.d(TAG, "SWP READER - Tag Remove");

6133

}

6134

mContext.sendBroadcast(swpReaderTagRemoveIntent);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

}

private final BroadcastReceiver x509CertificateReceiver = new BroadcastReceiver() {

6140

@Override

6141

public void onReceive(Context context, Intent intent) {

6142

boolean result = intent.getBooleanExtra(NxpConstants.EXTRA_RESULT, false);

6143

mNxpNfcController.setResultForCertificates(result);

}

};

private final BroadcastReceiver mEnableNfc = new BroadcastReceiver() {

6148

@Override

6149

public void onReceive(Context context, Intent intent) {

6150

String action = intent.getAction();

6151

Intent nfcDialogIntent = new Intent(mContext, EnableNfcDialogActivity.class);

6152

nfcDialogIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);

6153

mContext.startActivityAsUser(nfcDialogIntent, UserHandle.CURRENT);

}

};

Shashank vimal

2018-02-06 18:10:31 +0530

[diff] [blame]

6157

private final BroadcastReceiver mActivateSwpInterface = new BroadcastReceiver() {

6158

@Override

6159

public void onReceive(Context context, Intent intent) {

6160

6161

String action = intent.getAction();

6162

6163

if(NxpConstants.CAT_ACTIVATE_NOTIFY_ACTION.equals(action)){

6164

6165

Log.i(TAG, "Received ACTIVATE intent:" + action);

6166

6167

if(mSelectedSeId != ALL_SE_ID_TYPE){

6168

mDeviceHost.doSelectSecureElement(mSelectedSeId);

6169

Log.i(TAG, "Activated:" + mSelectedSeId);

6170

}

6171

else{

6172

int[] seList = mDeviceHost.doGetSecureElementList();

6173

Log.i(TAG, "Activating all SE:");

6174

6175

for(int i = 0; i < seList.length; i++){

6176

mDeviceHost.doActivateSecureElement(seList[i]);

6177

try{

6178

//Delay between two SE selection

Thread.sleep(200);

}catch(Exception e){

e.printStackTrace();

}

}

}

}

}

};

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6190

private final BroadcastReceiver mReceiver = new BroadcastReceiver() {

6191

@Override

6192

public void onReceive(Context context, Intent intent) {

6193

String action = intent.getAction();

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

6194

Log.e(TAG, "screen state "+action);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6195

if (action.equals(

6196

NativeNfcManager.INTERNAL_TARGET_DESELECTED_ACTION)) {

6197

// Perform applyRouting() in AsyncTask to serialize blocking calls

6198

new ApplyRoutingTask().execute();

6199

} else if ((action.equals(Intent.ACTION_SCREEN_ON)

6200

|| action.equals(Intent.ACTION_SCREEN_OFF)

6201

|| action.equals(Intent.ACTION_USER_PRESENT)) &&

6202

mState == NfcAdapter.STATE_ON) {

6203

// Perform applyRouting() in AsyncTask to serialize blocking calls

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

6204

int screenState = mScreenStateHelper.checkScreenState();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6205

if (action.equals(Intent.ACTION_SCREEN_OFF)) {

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

6206

if(mScreenState != ScreenStateHelper.SCREEN_STATE_OFF_LOCKED)

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6207

{

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

6208

Log.e(TAG, "screen state OFF required");

6209

screenState = mKeyguard.isKeyguardLocked() ?

6210

ScreenStateHelper.SCREEN_STATE_OFF_LOCKED :

6211

ScreenStateHelper.SCREEN_STATE_OFF_UNLOCKED;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6212

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6213

} else if (action.equals(Intent.ACTION_SCREEN_ON)) {

6214

screenState = mKeyguard.isKeyguardLocked() ?

6215

ScreenStateHelper.SCREEN_STATE_ON_LOCKED : ScreenStateHelper.SCREEN_STATE_ON_UNLOCKED;

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

6216

Log.e(TAG, "screen state on");

6217

/*

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6218

if(screenState == ScreenStateHelper.SCREEN_STATE_ON_LOCKED && mScreenState == ScreenStateHelper.SCREEN_STATE_OFF) {

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6219

} else if (screenState == ScreenStateHelper.SCREEN_STATE_ON_LOCKED && mScreenState == ScreenStateHelper.SCREEN_STATE_ON_LOCKED) {

6220

return;

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

6221

}*/

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6222

} else if (action.equals(Intent.ACTION_USER_PRESENT)) {

6223

if (mScreenState != ScreenStateHelper.SCREEN_STATE_ON_UNLOCKED) {

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

6224

Log.e(TAG, "screen state user present");

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6225

screenState = ScreenStateHelper.SCREEN_STATE_ON_UNLOCKED;

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

} else {

return;

}

}

Bhupendra Pawar

e1c7ede

2018-02-26 11:51:32 +0530

[diff] [blame]

6230

/* This piece of code is duplicate as MSG_APPLY_SCREEN_STATE

6231

is already calling applyRouting api */

6232

/*if(nci_version != NCI_VERSION_2_0) {

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

6233

new ApplyRoutingTask().execute(Integer.valueOf(screenState));

Bhupendra Pawar

e1c7ede

2018-02-26 11:51:32 +0530

[diff] [blame]

6234

}*/

Pratap Reddy

2018-03-15 16:54:33 +0530

[diff] [blame]

6235

6236

if( mDeviceHost.getEtsiReaederState() == STATE_SE_RDR_MODE_STOPPED ||

6237

mDeviceHost.getEtsiReaederState() == STATE_SE_RDR_MODE_INVALID) {

6238

sendMessage(NfcService.MSG_APPLY_SCREEN_STATE, screenState);

6239

} else {

6240

Log.e(TAG, "mPOS in progress holding screen state "+screenState);

6241

mScreenState = screenState;

6242

}

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

6243

Log.e(TAG, "screen state "+screenState);

6244

Log.e(TAG, "screen state mScreenState "+mScreenState);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6245

} else if (action.equals(Intent.ACTION_USER_SWITCHED)) {

nxpandroid

2017-07-12 18:25:41 +0530

[diff] [blame]

6246

int screenState = mScreenStateHelper.checkScreenState();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6247

int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, 0);

Suhas Suresh

e2a2ff0

2018-04-27 12:21:19 +0530

[diff] [blame]

6248

int beamSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;

6249

try {

6250

IPackageManager mIpm = IPackageManager.Stub.asInterface(ServiceManager.getService("package"));

6251

beamSetting = mIpm.getComponentEnabledSetting(new ComponentName(

6252

BeamShareActivity.class.getPackageName$(),

6253

BeamShareActivity.class.getName()),

6254

userId);

6255

} catch(RemoteException e) {

6256

Log.e(TAG, "Error int getComponentEnabledSetting for BeamShareActivity");

6257

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6258

synchronized (this) {

6259

mUserId = userId;

Suhas Suresh

e2a2ff0

2018-04-27 12:21:19 +0530

[diff] [blame]

6260

if (beamSetting == PackageManager.COMPONENT_ENABLED_STATE_DISABLED) {

6261

mIsNdefPushEnabled = false;

6262

} else {

6263

mIsNdefPushEnabled = true;

6264

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6265

}

6266

mP2pLinkManager.onUserSwitched(getUserId());

6267

if (mIsHceCapable) {

6268

mCardEmulationManager.onUserSwitched(getUserId());

6269

}

nxpandroid

2017-07-12 21:36:08 +0530

[diff] [blame]

6270

screenState = mScreenStateHelper.checkScreenState();

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6271

new ApplyRoutingTask().execute(Integer.valueOf(screenState));

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

}

};

private final BroadcastReceiver mOwnerReceiver = new BroadcastReceiver() {

6277

@Override

6278

public void onReceive(Context context, Intent intent) {

6279

String action = intent.getAction();

6280

if (action.equals(Intent.ACTION_PACKAGE_REMOVED) ||

6281

action.equals(Intent.ACTION_PACKAGE_ADDED) ||

6282

action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE) ||

6283

action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)) {

6284

updatePackageCache();

6285

nxpandroid

2016-11-18 19:48:53 +0530

[diff] [blame]

6286

} else if(action.equals(Intent.ACTION_SHUTDOWN)) {

6287

mPowerShutDown = true;

6288

if (DBG) Log.d(TAG,"Device is shutting down.");

6289

mDeviceHost.doSetScreenOrPowerState(ScreenStateHelper.POWER_STATE_OFF);

Suhas Suresh

2018-05-09 15:48:37 +0530

[diff] [blame]

6290

if (isNfcEnabled()) {

6291

mDeviceHost.shutdown();

6292

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

}

};

final BroadcastReceiver mAlaReceiver = new BroadcastReceiver() {

6298

@Override

6299

public void onReceive(Context context, Intent intent) {

6300

String action = intent.getAction();

6301

if (NfcAdapter.ACTION_ADAPTER_STATE_CHANGED.equals(intent.getAction())) {

6302

int state = intent.getIntExtra(NfcAdapter.EXTRA_ADAPTER_STATE,

6303

NfcAdapter.STATE_OFF);

6304

if (state == NfcAdapter.STATE_ON) {

6305

Log.e(TAG, "Loader service update start from NFC_ON Broadcast");

6306

NfcAlaService nas = new NfcAlaService();

nxpandroid

5d3fdf8

2017-07-31 16:11:33 +0530

[diff] [blame]

6307

int lsVersion = mNfcAla.doGetLSConfigVersion();

6308

6309

if(lsVersion >= LOADER_SERVICE_VERSION_LOW_LIMIT &&

6310

lsVersion <= LOADER_SERVICE_VERSION_HIGH_LIMIT)

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6311

nas.updateLoaderService();

}

}

}

};

private final BroadcastReceiver mPolicyReceiver = new BroadcastReceiver() {

6318

@Override

6319

public void onReceive(Context context, Intent intent){

6320

String action = intent.getAction();

6321

if (DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED

6322

.equals(action)) {

6323

enforceBeamShareActivityPolicy(context,

Suhas Suresh

a18dee0

2018-04-27 15:28:04 +0530

[diff] [blame]

6324

new UserHandle(getSendingUserId()));

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

}

}

};

Nikhil Chhabra

2018-01-08 20:48:49 +0530

[diff] [blame]

6329

private final IVrStateCallbacks mVrStateCallbacks = new IVrStateCallbacks.Stub() {

6330

@Override

6331

public void onVrStateChanged(boolean enabled) {

6332

synchronized (this) {

6333

mIsVrModeEnabled = enabled;

}

}

};

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6338

/**

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6339

* for debugging only - no i18n

6340

*/

6341

static String stateToString(int state) {

6342

switch (state) {

6343

case NfcAdapter.STATE_OFF:

6344

return "off";

6345

case NfcAdapter.STATE_TURNING_ON:

6346

return "turning on";

6347

case NfcAdapter.STATE_ON:

6348

return "on";

6349

case NfcAdapter.STATE_TURNING_OFF:

6350

return "turning off";

default:

return "<error>";

}

}

void dump(FileDescriptor fd, PrintWriter pw, String[] args) {

6357

if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)

6358

!= PackageManager.PERMISSION_GRANTED) {

6359

pw.println("Permission Denial: can't dump nfc from from pid="

6360

+ Binder.getCallingPid() + ", uid=" + Binder.getCallingUid()

6361

+ " without permission " + android.Manifest.permission.DUMP);

return;

}

synchronized (this) {

6366

pw.println("mState=" + stateToString(mState));

6367

pw.println("mIsZeroClickRequested=" + mIsNdefPushEnabled);

6368

pw.println("mScreenState=" + ScreenStateHelper.screenStateToString(mScreenState));

6369

pw.println("mNfcPollingEnabled=" + mNfcPollingEnabled);

6370

pw.println("mNfceeRouteEnabled=" + mNfceeRouteEnabled);

6371

pw.println("mOpenEe=" + mOpenEe);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6372

pw.println("mLockscreenPollMask=" + mLockscreenPollMask);

6373

pw.println(mCurrentDiscoveryParameters);

6374

mP2pLinkManager.dump(fd, pw, args);

6375

if (mIsHceCapable) {

6376

mCardEmulationManager.dump(fd, pw, args);

6377

}

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6378

mNfcDispatcher.dump(fd, pw, args);

Nikhil Chhabra

9645ab6

2018-01-09 18:44:05 +0530

[diff] [blame]

6379

pw.flush();

Nikhil Chhabra

1e1ac46

2018-01-10 12:53:43 +0530

[diff] [blame]

6380

mDeviceHost.dump(fd);

nxpandroid

2015-09-23 16:45:15 +0530

[diff] [blame]

6381

6382

}

6383

}

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

6384

/**

6385

* Update the status of all the services which were populated to commit to routing table

6386

*/

6387

public void updateStatusOfServices(boolean commitStatus) {

nxpandroid

2016-12-22 18:48:59 +0530

[diff] [blame]

6388

if(commitStatus == true)

6389

{

6390

mAidCache.setPreviousPreferredPaymentService(null);

6391

}

nxpandroid

2016-05-27 15:52:30 +0530

[diff] [blame]

6392

mCardEmulationManager.updateStatusOfServices(commitStatus);

6393

}

nxpandroid