/**
 * Start intercepting nfc events
 * @param activity activity that is going to receive nfc events
 * Note: invoke that while activity is in foreground
 */
private void enableReaderMode(Activity activity, final NfcConfiguration nfcConfiguration) {
    NfcAdapter.ReaderCallback callback = new NfcAdapter.ReaderCallback() {
        public void onTagDiscovered(Tag tag) {
            handler.onTag(tag);
        }
    };
    Bundle options = new Bundle();
    options.putInt(NfcAdapter.EXTRA_READER_PRESENCE_CHECK_DELAY, 50);
    int READER_FLAGS = NfcAdapter.FLAG_READER_NFC_A | NfcAdapter.FLAG_READER_NFC_B;
    if (nfcConfiguration.isDisableNfcDiscoverySound()) {
        READER_FLAGS |= NfcAdapter.FLAG_READER_NO_PLATFORM_SOUNDS;
    }

    if (nfcConfiguration.isSkipNdefCheck()) {
        READER_FLAGS |= NfcAdapter.FLAG_READER_SKIP_NDEF_CHECK;
    }
    adapter.enableReaderMode(activity, callback, READER_FLAGS, options);
}
 

@Override
public void onNewIntent(Intent intent) {
    Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
    String[] techList = tag.getTechList();
    boolean haveMifareUltralight = false;
    for (String tech : techList) {
        if (tech.indexOf("MifareUltralight") >= 0) {
            haveMifareUltralight = true;
            break;
        }
    }
    if (!haveMifareUltralight) {
        Toast.makeText(this, "不支持MifareUltralight数据格式", Toast.LENGTH_SHORT).show();
        return;
    }
    writeTag(tag);
}
 

private void dispatchTag(final Tag tag) {
if(dispatchOnUiThread) {
    if(Looper.myLooper() != Looper.getMainLooper()) {
        new Handler(Looper.getMainLooper()).post(new Runnable() {
                @Override
                public void run() {
                    tagDiscoveredListener.tagDiscovered(tag);
                }
            });
    } else {
        tagDiscoveredListener.tagDiscovered(tag);
    }

} else {
    new AsyncTask<Void, Void, Void>() {
 

@Override
public void onNewIntent(Intent intent) {
    Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
    String[] techList = tag.getTechList();
    boolean haveMifareUltralight = false;
    for (String tech : techList) {
        if (tech.indexOf("MifareUltralight") >= 0) {
            haveMifareUltralight = true;
            break;
        }
    }
    if (!haveMifareUltralight) {
        Toast.makeText(this, "不支持MifareUltralight数据格式", Toast.LENGTH_SHORT).show();
        return;
    }
    String data = readTag(tag);
    if (data != null)
        Toast.makeText(this, data, Toast.LENGTH_SHORT).show();
}
 

/**
 * 写入标签
 *
 * @param message
 * @param tag
 * @return
 */
public static boolean writeTag(NdefMessage message, Tag tag) {
    int size = message.toByteArray().length;
    try {
        Ndef ndef = Ndef.get(tag);
        if (ndef != null) {
            ndef.connect();
            if (!ndef.isWritable()) {
                return false;
            }
            if (ndef.getMaxSize() < size) {
                return false;
            }
            ndef.writeNdefMessage(message);
            return true;
        }
    } catch (Exception e) {
    }
    return false;
}
 

@TargetApi(Build.VERSION_CODES.KITKAT)
private void enableReaderMode(NfcAdapter adapter) {
    Bundle options = new Bundle();
    if(broadcomWorkaround) {
        /* This is a work around for some Broadcom chipsets that does
         * the presence check by sending commands that interrupt the
         * processing of the ongoing command.
         */
        options.putInt(NfcAdapter.EXTRA_READER_PRESENCE_CHECK_DELAY, DELAY_PRESENCE);
    }
    NfcAdapter.ReaderCallback callback = new NfcAdapter.ReaderCallback() {
            public void onTagDiscovered(Tag tag) {
                dispatchTag(tag);
            }
        };
    int flags = NfcAdapter.FLAG_READER_NFC_A | NfcAdapter.FLAG_READER_NFC_B;
    if(disableSounds) {
        flags = flags | NfcAdapter.FLAG_READER_NO_PLATFORM_SOUNDS;
    }
    if(disableNdefCheck) {
        flags = flags | NfcAdapter.FLAG_READER_SKIP_NDEF_CHECK;
    }
    adapter.enableReaderMode(activity, callback, flags, options);
}
 

@Override
public void tagDiscovered(final Tag t) {
    Log.d(TAG, "tagDiscovered " + t);
    mTag = t;
    if (mTransportFuture == null)
        return;

    final BTChipTransport transport = getTransport(t);
    if (transport == null)
        return;

    if (mTransportFuture.set(transport)) {
        if (mNfcWaitDialog == null)
            return;

        runOnUiThread(new Runnable() { public void run() { mNfcWaitDialog.hide(); } });
    }
}
 

/**
 * Factory method that creates NfcTagHandler for a given NFC Tag.
 *
 * @param tag @see android.nfc.Tag
 * @return NfcTagHandler or null when unsupported Tag is provided.
 */
public static NfcTagHandler create(Tag tag) {
    if (tag == null) return null;

    Ndef ndef = Ndef.get(tag);
    if (ndef != null) return new NfcTagHandler(ndef, new NdefHandler(ndef));

    NdefFormatable formattable = NdefFormatable.get(tag);
    if (formattable != null) {
        return new NfcTagHandler(formattable, new NdefFormattableHandler(formattable));
    }

    return null;
}
 

@Override
public void onTagDiscovered(Tag tag) {
	IsoDep isoDep = IsoDep.get(tag);
	IsoDepTransceiver transceiver = new IsoDepTransceiver(isoDep, this);
	Thread thread = new Thread(transceiver);
	thread.start();
}
 

/** @hide */
public NfcA(Tag tag) throws RemoteException {
    super(tag, TagTechnology.NFC_A);
    Bundle extras = tag.getTechExtras(TagTechnology.NFC_A);
    mSak = extras.getShort(EXTRA_SAK);
    mAtqa = extras.getByteArray(EXTRA_ATQA);
}
 

/**
 * Internal constructor, to be used by NfcAdapter
 * @hide
 */
public NfcBarcode(Tag tag) throws RemoteException {
    super(tag, TagTechnology.NFC_BARCODE);
    Bundle extras = tag.getTechExtras(TagTechnology.NFC_BARCODE);
    if (extras != null) {
        mType = extras.getInt(EXTRA_BARCODE_TYPE);
    } else {
        throw new NullPointerException("NfcBarcode tech extras are null.");
    }
}
 

/**
 * Initialize a MIFARE Classic reader for the given tag.
 * @param tag The tag to operate on.
 */
private MCReader(Tag tag) {
    MifareClassic tmpMFC;
    try {
        tmpMFC = MifareClassic.get(tag);
    } catch (Exception e) {
        Log.e(LOG_TAG, "Could not create MIFARE Classic reader for the"
                + "provided tag (even after patching it).");
        throw e;
    }
    mMFC = tmpMFC;
}
 

/** @hide */
public NfcB(Tag tag) throws RemoteException {
    super(tag, TagTechnology.NFC_B);
    Bundle extras = tag.getTechExtras(TagTechnology.NFC_B);
    mAppData = extras.getByteArray(EXTRA_APPDATA);
    mProtInfo = extras.getByteArray(EXTRA_PROTINFO);
}
 

public static Pair<String, String> parseIntent(Intent intent) throws Exception {

        Tag tagFromIntent = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
        Parcelable[] messages = intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES);

        if (tagFromIntent != null && messages != null) {
            return getCameraWifiSettingsFromTag(tagFromIntent, messages);
        }

        return null;
    }
 

/** @hide */
public IsoDep(Tag tag)
        throws RemoteException {
    super(tag, TagTechnology.ISO_DEP);
    Bundle extras = tag.getTechExtras(TagTechnology.ISO_DEP);
    if (extras != null) {
        mHiLayerResponse = extras.getByteArray(EXTRA_HI_LAYER_RESP);
        mHistBytes = extras.getByteArray(EXTRA_HIST_BYTES);
    }
}
 

/** @hide */
public NfcF(Tag tag) throws RemoteException {
    super(tag, TagTechnology.NFC_F);
    Bundle extras = tag.getTechExtras(TagTechnology.NFC_F);
    if (extras != null) {
        mSystemCode = extras.getByteArray(EXTRA_SC);
        mManufacturer = extras.getByteArray(EXTRA_PMM);
    }
}
 

/**
 * Sets listener to Nfc session discovery
 * @param listener the listener
 */
public void setListener(final @NonNull NfcSessionListener listener) {
    dispatcher.setOnTagHandler(new NfcDispatcher.OnTagHandler() {
        @Override
        public void onTag(Tag tag) {
            listener.onSessionReceived(new NfcSession(tag));
        }
    });
}
 

/**
 * {@inheritDoc}
 */
@Override
public boolean writeGeolocationToTagFromIntent(Double latitude, Double longitude, @NotNull Intent intent) throws FormatException, ReadOnlyTagException, InsufficientCapacityException, TagNotPresentException {
    final NdefMessage ndefMessage = mNfcMessageUtility.createGeolocation(latitude, longitude);
    final Tag tag = retrieveTagFromIntent(intent);
    return writeToTag(ndefMessage, tag);
}
 

/**
 * Parses nfc tag and extracts otp credential from it
 * @param tag an NDEF compatible tag
 * @return OTP data
 * @throws ParseTagException if tag has no NDEF Tag Technology or there is no YK OTP payload
 */
public static @NonNull String parseTag(Tag tag) throws ParseTagException {
    Ndef ndef = Ndef.get(tag);
    if (ndef == null) {
        throw new ParseTagException("Tag is not NDEF formatted");
    }
    NdefMessage message;
    try {
        ndef.connect();
        message = ndef.getNdefMessage();
    } catch (FormatException | IOException e) {
        message = ndef.getCachedNdefMessage();
    } finally {
        try {
            ndef.close();
        } catch (IOException ignore) {
        }
    }

    if (message == null) {
        throw new ParseTagException("Couldn't read ndef message");
    }

    String parsedData = parseNdefMessage(message);
    if (parsedData != null) {
        return parsedData;
    }
    throw new ParseTagException("Tag doesn't have YK OTP payload");
}
 

/**
 * Opens a connection with the ID by doing BAC
 * Uses hardcoded parameters for now
 *
 * @param tag - NFC tag that started this activity (ID NFC tag)
 * @return PassportService - passportservice that has an open connection with the ID
 */
public PassportService openConnection(Tag tag, final DocumentData docData) throws CardServiceException {
    try {
        IsoDep nfc = IsoDep.get(tag);
        CardService cs = CardService.getInstance(nfc);
        this.ps = new PassportService(cs);
        this.ps.open();

        // Get the information needed for BAC from the data provided by OCR
        this.ps.sendSelectApplet(false);
        BACKeySpec bacKey = new BACKeySpec() {
            @Override
            public String getDocumentNumber() {
                return docData.getDocumentNumber();
            }

            @Override
            public String getDateOfBirth() { return docData.getDateOfBirth(); }

            @Override
            public String getDateOfExpiry() { return docData.getExpiryDate(); }
        };
        ps.doBAC(bacKey);
        return ps;
    } catch (CardServiceException ex) {
        try {
            ps.close();
        } catch (Exception ex2) {
            ex2.printStackTrace();
        }
        throw ex;
    }
}
 

@Override
public void onNewIntent(Intent intent) {
    if (mPackageName == null)
        return;
    //1.获取Tag对象
    Tag detectedTag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
    writeNFCTag(detectedTag);
}
 

@Override
public void onNewIntent(Intent intent) {
    if (mText == null)
        return;
    //获取Tag对象
    Tag detectedTag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
    NdefMessage ndefMessage = new NdefMessage(
            new NdefRecord[]{createTextRecord(mText)});
    boolean result = writeTag(ndefMessage, detectedTag);
    if (result) {
        Toast.makeText(this, "写入成功", Toast.LENGTH_SHORT).show();
    } else {
        Toast.makeText(this, "写入失败", Toast.LENGTH_SHORT).show();
    }
}
 

/**
 * 写数据
 *
 * @param ndefMessage 创建好的NDEF文本数据
 * @param tag         标签
 * @return
 */
public static boolean writeTag(NdefMessage ndefMessage, Tag tag) {
    try {
        Ndef ndef = Ndef.get(tag);
        ndef.connect();
        ndef.writeNdefMessage(ndefMessage);
        return true;
    } catch (Exception e) {
    }
    return false;
}
 

/**
 * Constructor
 * 
 * @param _nfcTag
 */
public NfcBankomatCardReader(Tag nfcTag, Context ctx) {
	super();
	this._nfcTag = nfcTag;
	this._ctl = AppController.getInstance();
	this._tagList = new ArrayList<TagAndValue>();
	this._ctx = ctx;
}
 

public void onNewIntent(Intent intent) {
    Tag detectedTag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
    NdefMessage ndefMessage = new NdefMessage(new NdefRecord[]{createUriRecord(mUri)});
    boolean result = writeTag(ndefMessage, detectedTag);
    if (result) {
        Toast.makeText(this, "写入成功", Toast.LENGTH_SHORT).show();
    } else {
        Toast.makeText(this, "写入失败", Toast.LENGTH_SHORT).show();
    }
}
 

/**
 * NFC に書き込むを確認するダイアログを表示します.
 *
 * @param tag 書き込み先のNFCタグ
 */
private void openWriteTag(final Tag tag) {
    runOnUiThread(() -> new AlertDialog.Builder(NFCWriterActivity.this)
            .setTitle(R.string.activity_nfc_write_dialog_title)
            .setMessage(R.string.activity_nfc_write_dialog_message)
            .setPositiveButton(R.string.activity_nfc_setting_error_btn_ok, (dialogInterface, i) -> {
                try {
                    writeTag(tag);
                    postTagWriterActivityResult(TagConstants.RESULT_SUCCESS);
                } catch (NFCWriteException e) {
                    switch (e.getCode()) {
                        default:
                        case IO_ERROR:
                            postTagWriterActivityResult(TagConstants.RESULT_FAILED);
                            break;
                        case INVALID_FORMAT:
                            postTagWriterActivityResult(TagConstants.RESULT_INVALID_FORMAT);
                            break;
                        case NOT_WRITABLE:
                            postTagWriterActivityResult(TagConstants.RESULT_NOT_WRIATEBLE);
                            break;
                    }
                }
            })
            .setNegativeButton(R.string.activity_nfc_setting_error_btn_cancel, (dialogInterface, i) -> finish())
            .show());
}
 

private static synchronized void doTheScan(final Activity context, Tag tag, boolean showui) {
    synchronized (tag_lock) {
        if (!tag_discovered) {
            if (!useNFC()) return;
            if ((!last_read_succeeded) && (JoH.ratelimit("nfc-debounce", 5)) || (JoH.ratelimit("nfc-debounce", 60))) {
                tag_discovered = true;
                Home.staticBlockUI(context, true);
                last_tag_discovered = JoH.tsl();
                if (showui) {
                    context.startActivity(new Intent(context, NFCScanningX.class));
                } else {
                    NFCReaderX.vibrate(context, 0);
                    JoH.static_toast_short(gs(R.string.scanning));
                }
                if (d)
                    Log.d(TAG, "NFC tag discovered - going to read data");
                new NfcVReaderTask(context).executeOnExecutor(xdrip.executor, tag);
            } else {
                if (JoH.tsl() - last_tag_discovered > 5000) {
                    vibrate(context, 4);
                    JoH.static_toast_short(gs(R.string.not_so_quickly_wait_60_seconds));
                }
            }
        } else {
            Log.d(TAG, "Tag already discovered!");
            if (JoH.tsl() - last_tag_discovered > 60000)
                tag_discovered = false; // don't lock too long
        }
    } // lock
}
 

public static void tagFound(Activity context, Intent data) {

        if (NfcAdapter.ACTION_TECH_DISCOVERED.equals(data.getAction())) {
            Tag tag = data.getParcelableExtra(NfcAdapter.EXTRA_TAG);
            doTheScan(context, tag, true);
        }
    }
 

public static void tagFound(Activity context, Intent data) {

        if (NfcAdapter.ACTION_TECH_DISCOVERED.equals(data.getAction())) {
            Tag tag = data.getParcelableExtra(NfcAdapter.EXTRA_TAG);
            doTheScan(context, tag, true);
        }
    }
 

private static synchronized void doTheScan(final Activity context, Tag tag, boolean showui) {
    synchronized (tag_lock) {
        if (!tag_discovered) {
            if (!useNFC()) return;
            if ((!last_read_succeeded) && (JoH.ratelimit("nfc-debounce", 5)) || (JoH.ratelimit("nfc-debounce", 60))) {
                tag_discovered = true;
                Home.staticBlockUI(context, true);
                last_tag_discovered = JoH.tsl();
                if (showui) {
                    context.startActivity(new Intent(context, NFCScanningX.class));
                } else {
                    NFCReaderX.vibrate(context, 0);
                    JoH.static_toast_short(gs(R.string.scanning));
                }
                if (d)
                    Log.d(TAG, "NFC tag discovered - going to read data");
                new NfcVReaderTask(context).executeOnExecutor(xdrip.executor, tag);
            } else {
                if (JoH.tsl() - last_tag_discovered > 5000) {
                    vibrate(context, 4);
                    JoH.static_toast_short(gs(R.string.not_so_quickly_wait_60_seconds));
                }
            }
        } else {
            Log.d(TAG, "Tag already discovered!");
            if (JoH.tsl() - last_tag_discovered > 60000)
                tag_discovered = false; // don't lock too long
        }
    } // lock
}