[webnfc] Implement push method for Android nfc mojo service.

device/nfc/android/java/src/org/chromium/device/nfc/NfcImpl.java

Index: device/nfc/android/java/src/org/chromium/device/nfc/NfcImpl.java
diff --git a/device/nfc/android/java/src/org/chromium/device/nfc/NfcImpl.java b/device/nfc/android/java/src/org/chromium/device/nfc/NfcImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e1594ae61f005db572e1e7f145450bc679dacc4
--- /dev/null
+++ b/device/nfc/android/java/src/org/chromium/device/nfc/NfcImpl.java
@@ -0,0 +1,411 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.

[timvolodine, 2016/04/26 14:58:27]

2015 -> 2016

[shalamov, 2016/04/26 21:56:52]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.device.nfc;
+
+import android.Manifest;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.nfc.FormatException;
+import android.nfc.NdefMessage;
+import android.nfc.NdefRecord;
+import android.nfc.NfcAdapter;
+import android.nfc.NfcAdapter.ReaderCallback;
+import android.nfc.NfcManager;
+import android.nfc.Tag;
+import android.nfc.TagLostException;
+import android.nfc.tech.Ndef;
+import android.nfc.tech.NdefFormatable;
+import android.nfc.tech.TagTechnology;
+import android.os.Build;
+import android.os.Process;
+import android.support.annotation.Nullable;
+
+import org.chromium.base.ApplicationStatus;
+import org.chromium.base.Log;
+import org.chromium.mojo.bindings.Callbacks;
+import org.chromium.mojo.system.MojoException;
+import org.chromium.mojom.device.Nfc;
+import org.chromium.mojom.device.NfcClient;
+import org.chromium.mojom.device.NfcError;
+import org.chromium.mojom.device.NfcErrorType;
+import org.chromium.mojom.device.NfcMessage;
+import org.chromium.mojom.device.NfcPushOptions;
+import org.chromium.mojom.device.NfcPushTarget;
+import org.chromium.mojom.device.NfcRecord;
+import org.chromium.mojom.device.NfcRecordType;
+import org.chromium.mojom.device.NfcWatchOptions;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Android implementation of the NFC mojo service defined in
+ * device/nfc/nfc.mojom.
+ */
+public class NfcImpl implements Nfc {
+    private static final String TAG = "NfcImpl";
+    private static final String DOMAIN = "w3.org";
+    private static final String TYPE = "webnfc";
+    private static final String TEXT_MIME = "text/plain";
+    private static final String CHARSET_UTF8 = ";charset=UTF-8";
+    private static final String CHARSET_UTF16 = ";charset=UTF-16";
+
+    private NfcManager mNfcManager;

[timvolodine, 2016/04/26 14:58:27]

final?

[shalamov, 2016/04/26 21:56:53]

Done.

+    private NfcAdapter mNfcAdapter;

[timvolodine, 2016/04/26 14:58:27]

final?

[shalamov, 2016/04/26 21:56:53]

Done.

+    private final Context mContext;
+    private Activity mActivity;
+    private boolean mHasPermission;

[timvolodine, 2016/04/26 14:58:26]

final? same for mAcitivy above

[shalamov, 2016/04/26 21:56:53]

Done.

+    private ReaderCallbackHandler mReaderCallbackHandler;
+    private PendingPushOperation mPendingPushOperation;
+    private NfcTagWriter mTagWriter;

[ncarter (slow), 2016/04/25 20:03:14]

There are very few comments in this file overall. For the @Overrides that's
probably okay (since the semantics ought to be documented in the mojom). But,
javadoc on these members would be helpful, and javadoc on some of the private
methods certainly wouldn't hurt.

[timvolodine, 2016/04/26 14:58:26]

+1, bit more documentation would be great

[shalamov, 2016/04/26 21:56:53]

Done.

[shalamov, 2016/04/26 21:56:53]

Done.

+
+    public NfcImpl(Context context) {
+        mContext = context;
+        int permission =
+                context.checkPermission(Manifest.permission.NFC, Process.myPid(), Process.myUid());
+        mHasPermission = permission == PackageManager.PERMISSION_GRANTED;
+        if (mHasPermission) {
+            mActivity = ApplicationStatus.getLastTrackedFocusedActivity();
+            mNfcManager = (NfcManager) mContext.getSystemService(Context.NFC_SERVICE);
+            if (mNfcManager == null) {
+                Log.w(TAG, "NFC is not supported.");
+            } else {
+                mNfcAdapter = mNfcManager.getDefaultAdapter();
+            }
+        } else {
+            Log.w(TAG, "NFC operations are not permitted.");
+        }
+    }
+
+    // Public methods

[ncarter (slow), 2016/04/25 20:03:14]

I don't think this is necessary.

[shalamov, 2016/04/26 21:56:52]

Done.

+    @Override
+    public void setClient(NfcClient client) {}
+
+    @Override
+    public void push(NfcMessage message, NfcPushOptions options, PushResponse callback) {
+        if (!checkIfReady(callback)) return;
+
+        if (options.target == NfcPushTarget.PEER) {
+            callback.call(createError(NfcErrorType.NOT_SUPPORTED));
+            return;
+        }
+
+        if (mPendingPushOperation != null) {
+            mPendingPushOperation.complete(createError(NfcErrorType.OPERATION_CANCELLED));
+        }
+
+        mPendingPushOperation = new PendingPushOperation(message, options, callback);
+        enableReaderMode();
+        processPendingPushOperation();
+    }
+
+    @Override
+    public void cancelPush(int target, CancelPushResponse callback) {
+        if (!checkIfReady(callback)) return;
+
+        if (target == NfcPushTarget.PEER) {
+            callback.call(createError(NfcErrorType.NOT_SUPPORTED));
+            return;
+        }
+
+        if (mPendingPushOperation != null) {
+            mPendingPushOperation.complete(createError(NfcErrorType.OPERATION_CANCELLED));
+            mPendingPushOperation = null;
+            callback.call(null);
+        } else {
+            callback.call(createError(NfcErrorType.NOT_FOUND));
+        }
+    }
+
+    @Override
+    public void watch(NfcWatchOptions options, WatchResponse callback) {
+        if (!checkIfReady(callback)) return;

[timvolodine, 2016/04/26 14:58:27]

should this have a TODO? also below for cancelWatch/cancelAllWatches?

[shalamov, 2016/04/26 21:56:53]

Done.

+    }
+
+    @Override
+    public void cancelWatch(int id, CancelWatchResponse callback) {
+        if (!checkIfReady(callback)) return;
+    }
+
+    @Override
+    public void cancelAllWatches(CancelAllWatchesResponse callback) {
+        if (!checkIfReady(callback)) return;
+    }
+
+    @Override
+    public void suspendNfcOperations() {}

[timvolodine, 2016/04/26 14:58:27]

is this intentionally empty or is this a also TODO? (same for resume below)

[shalamov, 2016/04/26 21:56:52]

Done.

+
+    @Override
+    public void resumeNfcOperations() {}
+
+    @Override
+    public void close() {}
+
+    @Override
+    public void onConnectionError(MojoException e) {}
+
+    // Implementation

[ncarter (slow), 2016/04/25 20:03:14]

Class comment for PendingPushOperation? Can be a one-liner.

[shalamov, 2016/04/26 21:56:52]

Done.

+    private static class PendingPushOperation {
+        private final NfcMessage mNfcMessage;
+        private final NfcPushOptions mNfcPushOptions;
+        private final PushResponse mPushResponseCallback;
+
+        public PendingPushOperation(
+                NfcMessage message, NfcPushOptions options, PushResponse callback) {
+            mNfcMessage = message;
+            mNfcPushOptions = options;
+            mPushResponseCallback = callback;
+        }
+
+        public void complete(NfcError error) {
+            if (mPushResponseCallback != null) mPushResponseCallback.call(error);
+        }
+
+        public NfcMessage message() {
+            return mNfcMessage;
+        }
+        public NfcPushOptions pushOptions() {
+            return mNfcPushOptions;
+        }
+    }
+
+    private NfcError createError(int errorType) {
+        NfcError error = new NfcError();
+        error.errorType = errorType;
+        return error;
+    }
+
+    @Nullable
+    private NfcError checkIfReady() {
+        if (!mHasPermission) {
+            return createError(NfcErrorType.SECURITY);
+        } else if (mNfcManager == null || mNfcAdapter == null
+                || Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
+            return createError(NfcErrorType.NOT_SUPPORTED);
+        } else if (!mNfcAdapter.isEnabled()) {
+            return createError(NfcErrorType.DEVICE_DISABLED);
+        }
+        return null;
+    }
+
+    private boolean checkIfReady(Callbacks.Callback2<Integer, NfcError> callback) {
+        NfcError error = checkIfReady();
+        if (error == null) return true;
+        callback.call(0, error);
+        return false;
+    }
+
+    private boolean checkIfReady(Callbacks.Callback1<NfcError> callback) {
+        NfcError error = checkIfReady();
+        if (error == null) return true;
+        callback.call(error);
+        return false;
+    }
+
+    @TargetApi(Build.VERSION_CODES.KITKAT)
+    private static class ReaderCallbackHandler implements ReaderCallback {
+        private final NfcImpl mNfcImpl;
+
+        public ReaderCallbackHandler(NfcImpl impl) {
+            mNfcImpl = impl;
+        }
+
+        @Override
+        public void onTagDiscovered(Tag tag) {
+            mNfcImpl.onTagDiscovered(tag);
+        }
+    }
+
+    private void enableReaderMode() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) return;
+        if (mReaderCallbackHandler != null) return;
+
+        mReaderCallbackHandler = new ReaderCallbackHandler(this);
+        mNfcAdapter.enableReaderMode(mActivity, mReaderCallbackHandler,
+                NfcAdapter.FLAG_READER_NFC_A | NfcAdapter.FLAG_READER_NFC_B
+                        | NfcAdapter.FLAG_READER_NFC_F | NfcAdapter.FLAG_READER_NFC_V,
+                null);
+    }
+
+    private void disableReaderMode() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) return;
+
+        mReaderCallbackHandler = null;
+        mNfcAdapter.disableReaderMode(mActivity);
+    }
+
+    private interface TagTechnologyWriter {
+        public void write(NdefMessage message)
+                throws IOException, TagLostException, FormatException;
+    }
+
+    private static class NdefWriter implements TagTechnologyWriter {
+        private final Ndef mNdef;
+
+        NdefWriter(Ndef ndef) {
+            mNdef = ndef;
+        }
+
+        public void write(NdefMessage message)
+                throws IOException, TagLostException, FormatException {
+            mNdef.writeNdefMessage(message);
+        }
+    }
+
+    private static class NdefFormattableWriter implements TagTechnologyWriter {
+        private final NdefFormatable mNdefFormattable;
+
+        NdefFormattableWriter(NdefFormatable ndefFormattable) {
+            mNdefFormattable = ndefFormattable;
+        }
+
+        public void write(NdefMessage message)
+                throws IOException, TagLostException, FormatException {
+            mNdefFormattable.format(message);
+        }
+    }
+
+    private static class NfcTagWriter {
+        private final TagTechnology mTech;
+        private final TagTechnologyWriter mTechWriter;
+        private boolean mWasConnected = false;
+
+        public static NfcTagWriter create(Tag tag) {
+            if (tag == null) return null;
+
+            Ndef ndef = Ndef.get(tag);
+            if (ndef != null) return new NfcTagWriter(ndef, new NdefWriter(ndef));
+
+            NdefFormatable formattable = NdefFormatable.get(tag);
+            if (formattable != null) {
+                return new NfcTagWriter(formattable, new NdefFormattableWriter(formattable));
+            }
+
+            return null;
+        }
+
+        private NfcTagWriter(TagTechnology tech, TagTechnologyWriter writer) {
+            mTech = tech;
+            mTechWriter = writer;
+        }
+
+        public void connect() throws IOException, TagLostException {
+            if (!mTech.isConnected()) {
+                mTech.connect();
+                mWasConnected = true;
+            }
+        }
+
+        public void close() throws IOException {
+            mTech.close();
+        }
+
+        public void write(NdefMessage message)
+                throws IOException, TagLostException, FormatException {
+            mTechWriter.write(message);
+        }
+
+        public boolean isTagOutOfRange() {
+            try {
+                connect();
+            } catch (IOException e) {
+                return mWasConnected;
+            }
+            return false;
+        }
+    }
+
+    private static class InvalidMessageException extends Exception {}
+
+    private NdefMessage toNdefMessage(NfcMessage message) throws InvalidMessageException {
+        if (message == null || message.data.length == 0) throw new InvalidMessageException();
+
+        try {
+            List<NdefRecord> records = new ArrayList<NdefRecord>();
+            for (NfcRecord record : message.data) {
+                records.add(toNdefRecord(record));
+            }
+            records.add(NdefRecord.createExternal(DOMAIN, TYPE, message.url.getBytes()));
+            NdefRecord[] ndefRecords = new NdefRecord[records.size()];
+            records.toArray(ndefRecords);
+            return new NdefMessage(ndefRecords);
+        } catch (UnsupportedEncodingException | InvalidMessageException
+                | IllegalArgumentException e) {
+            throw new InvalidMessageException();
+        }
+    }
+
+    private String getCharset(NfcRecord record) {
+        if (record.mediaType.endsWith(CHARSET_UTF8)) return "UTF-8";
+
+        if (record.mediaType.endsWith(CHARSET_UTF16)) return "UTF-16LE";

[timvolodine, 2016/04/26 14:58:27]

why UTF-16LE? CHARSET_UTF16 doesn't specify LE.

[shalamov, 2016/04/26 21:56:53]

When 16bit WTF::String data is converted to bytearray, there is no BOM.
According to
http://developer.android.com/reference/java/nio/charset/Charset.html UTF-16 with
no BOM will be interpreted as UTF-16BE. When I tested writing unicode data, I
noticed that strings are incorrect, because bytearray that I received from blink
side had LE byte order. I also simplified blink side and sending UTF-8 encoded
strings whenever possible. https://codereview.chromium.org/1708543002/#ps160001

[timvolodine, 2016/04/28 17:06:34]

yes utf-16be usually tends to be the default, maybe this warrants a comment like
you explained above.

[shalamov, 2016/05/11 14:09:57]

Done.

+
+        Log.w(TAG, "Unknown charset, using UTF-8 by default.");
+        return "UTF-8";
+    }
+
+    private NdefRecord toNdefRecord(NfcRecord record)
+            throws InvalidMessageException, IllegalArgumentException, UnsupportedEncodingException {
+        switch (record.recordType) {
+            case NfcRecordType.URL:
+                return NdefRecord.createUri(new String(record.data, getCharset(record)));
+            case NfcRecordType.TEXT:
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                    return NdefRecord.createTextRecord(
+                            "en-US", new String(record.data, getCharset(record)));
+                } else {
+                    return NdefRecord.createMime(TEXT_MIME, record.data);
+                }
+            case NfcRecordType.JSON:
+            case NfcRecordType.OPAQUE_RECORD:
+                return NdefRecord.createMime(record.mediaType, record.data);
+            default:
+                throw new InvalidMessageException();
+        }
+    }
+
+    private void pendingPushOperationCompleted(NfcError error) {
+        if (mPendingPushOperation != null) {
+            mPendingPushOperation.complete(error);
+            mPendingPushOperation = null;
+        }
+
+        if (error != null) mTagWriter = null;
+    }
+
+    private void processPendingPushOperation() {
+        if (mTagWriter == null || mPendingPushOperation == null) return;
+
+        if (mTagWriter.isTagOutOfRange()) {
+            mTagWriter = null;
+            return;
+        }
+
+        try {
+            mTagWriter.connect();
+            mTagWriter.write(toNdefMessage(mPendingPushOperation.message()));
+            pendingPushOperationCompleted(null);
+            mTagWriter.close();
+        } catch (InvalidMessageException e) {
+            Log.w(TAG, "Cannot write data to NFC tag. Invalid NfcMessage.");
+            pendingPushOperationCompleted(createError(NfcErrorType.INVALID_MESSAGE));
+        } catch (TagLostException e) {
+            Log.w(TAG, "Cannot write data to NFC tag. Tag is lost.");
+            pendingPushOperationCompleted(createError(NfcErrorType.IO_ERROR));
+        } catch (FormatException | IOException e) {
+            Log.w(TAG, "Cannot write data to NFC tag. IO_ERROR.");
+            pendingPushOperationCompleted(createError(NfcErrorType.IO_ERROR));
+        }
+    }
+
+    public void onTagDiscovered(Tag tag) {
+        mTagWriter = NfcTagWriter.create(tag);
+        processPendingPushOperation();
+    }
+}