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

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

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// 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.NfcAdapter;
+import android.nfc.NfcAdapter.ReaderCallback;
+import android.nfc.NfcManager;
+import android.nfc.Tag;
+import android.nfc.TagLostException;
+import android.os.Build;
+import android.os.Process;
+import android.support.annotation.Nullable;
+
+import org.chromium.base.Log;
+import org.chromium.mojo.bindings.Callbacks;
+import org.chromium.mojo.system.MojoException;
+import org.chromium.mojom.device.nfc.Nfc;
+import org.chromium.mojom.device.nfc.NfcClient;
+import org.chromium.mojom.device.nfc.NfcError;
+import org.chromium.mojom.device.nfc.NfcErrorType;
+import org.chromium.mojom.device.nfc.NfcMessage;
+import org.chromium.mojom.device.nfc.NfcPushOptions;
+import org.chromium.mojom.device.nfc.NfcPushTarget;
+import org.chromium.mojom.device.nfc.NfcWatchOptions;
+
+import java.io.IOException;
+
+/**
+ * Android implementation of the NFC mojo service defined in
+ * device/nfc/nfc.mojom.
+ */
+public class NfcImpl implements Nfc {
+    private static final String TAG = "NfcImpl";
+
+    /**
+     * Used to get instance of NFC adapter, @see android.nfc.NfcManager
+     */
+    private final NfcManager mNfcManager;
+
+    /**
+     * NFC adapter. @see android.nfc.NfcAdapter
+     */
+    private final NfcAdapter mNfcAdapter;
+
+    /**
+     * Activity object that is requred to enable / disable NFC reader mode operations.
+     */
+    private final Activity mActivity;

[Ted C, 2016/05/12 18:23:20]

this has the same problem I mentioned before.  the activity can change for a
webcontents.

In particular, you can open a tab in a Chrome Custom Tab, then you can reparent
(i.e. open in chrome option) the tab into Chrome.  This moves the tab from one
activity to another.

The main method that causes problem is:
ContentViewCore#updateWindowAndroid

But.....there are some sad problems since that is a relatively new addition and
you are one of the first people to hit this not in the chrome layer/

In Chrome, you can listen to changes on a Tab via:
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/android/jav...

So I have a few follow up questions/thoughts:

1.) What can device/ depend on via DEPS?  I suspect content/ is potentially too
broad?  How about ui/?

2.) Ideally, you take a ContentViewCore, which would give you access the
WindowAndroid.  Then we need to add some observer to be notified when the
WindowAndroid changes.

If you can't access content but could depend on ui/, then I would think we could
add a couple interfaces:

interface WindowAndroidProvider {
    WindowAndroid getWindowAndroid();

    void addWindowAndroidChangedObserver(WindowAndroidChangedObserver observer);

    void removeWindowAndroidChangedObserver(WindowAndroidChangedObserver
observer);
}

interface WindowAndroidChangedObserver {
    void onWindowAndroidChanged(WindowAndroid oldWindowAndroid, WindowAndroid
newWindowAndroid);
}

Then, this class would be pass the window android provider, you would register
as a change observer and keep the activity from the active window android.  When
the window android changes, you'd unregister from old activity and register on
the new one.

Again, sorry for putting you through the ringer, but you are the first one to
hit this at this level.  Let me know if this isn't clear or if the dependencies
need to be tweaked and I'll help as much as I can.

[Yusuf, 2016/05/12 22:06:25]

Another solution would be to construct the impl class with a ContentViewCore(or
WebContents) cached instead of caching the activity.

There are 4 uses of mActivity here. Two of them (checkPermission and
getSystemService) can be used through a cached application context inside the
impl class here. The other two is needed to enable and disable reader mode and
those two can use the contentviewcore to get the valid windowandroid and the
activity through that (similar to what the factory inside the ServiceRegistrar
does)

+
+    /**
+     * Flag that indicates whether NFC permission is granted.
+     */
+    private final boolean mHasPermission;
+
+    /**
+     * Implementation of android.nfc.NfcAdapter.ReaderCallback. @see ReaderCallbackHandler
+     */
+    private ReaderCallbackHandler mReaderCallbackHandler;
+
+    /**
+     * Object that contains data that was passed to method
+     * #push(NfcMessage message, NfcPushOptions options, PushResponse callback)
+     * @see PendingPushOperation
+     */
+    private PendingPushOperation mPendingPushOperation;
+
+    /**
+     * Utility that provides I/O operations for a Tag. Created on demand when Tag is found.
+     * @see NfcTagHandler
+     */
+    private NfcTagHandler mTagHandler;
+
+    public NfcImpl(Activity activity) {
+        mActivity = activity;
+
+        if (mActivity != null) {
+            int permission = mActivity.checkPermission(
+                    Manifest.permission.NFC, Process.myPid(), Process.myUid());
+            mHasPermission = permission == PackageManager.PERMISSION_GRANTED;
+        } else {
+            mHasPermission = false;
+        }
+
+        if (mHasPermission && Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+            mNfcManager = (NfcManager) mActivity.getSystemService(Context.NFC_SERVICE);
+            if (mNfcManager != null) {
+                mNfcAdapter = mNfcManager.getDefaultAdapter();
+            } else {
+                Log.w(TAG, "NFC is not supported.");
+                mNfcAdapter = null;
+            }
+        } else {
+            Log.w(TAG, "NFC operations are not permitted.");
+            mNfcAdapter = null;
+            mNfcManager = null;
+        }
+    }
+
+    /**
+     * Sets NfcClient. NfcClient interface is used to notify mojo NFC service client when NFC
+     * device is in proximity and has NfcMessage that matches NfcWatchOptions criteria.
+     * @see Nfc#watch(NfcWatchOptions options, WatchResponse callback)
+     *
+     * @param client @see NfcClient
+     */
+    @Override
+    public void setClient(NfcClient client) {
+        // TODO(shalamov): Should be implemented when watch() is implemented.
+    }
+
+    /**
+     * Pushes NfcMessage to Tag or Peer, whenever NFC device is in proximity. At the moment, only
+     * passive NFC devices are supported (NfcPushTarget.TAG).
+     *
+     * @param message that should be pushed to NFC device.
+     * @param options that contain information about timeout and target device type.
+     * @param callback that is used to notify when push operation is completed.
+     */
+    @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 previous pending push operation is not completed, subsequent call
+        // should cancel pending operation.
+        if (mPendingPushOperation != null) {
+            mPendingPushOperation.complete(createError(NfcErrorType.OPERATION_CANCELLED));
+        }
+
+        mPendingPushOperation = new PendingPushOperation(message, options, callback);
+        enableReaderMode();
+        processPendingPushOperation();
+    }
+
+    /**
+     * Cancels pending push operation.
+     * At the moment, only passive NFC devices are supported (NfcPushTarget.TAG).
+     *
+     * @param target @see NfcPushTarget
+     * @param callback that is used to notify caller when cancelPush() is completed.
+     */
+    @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);
+            disableReaderMode();
+        } else {
+            callback.call(createError(NfcErrorType.NOT_FOUND));
+        }
+    }
+
+    /**
+     * Watch method allows to set filtering criteria for NfcMessages that are found when NFC device
+     * is within proximity. On success, watch ID is returned to caller through WatchResponse
+     * callback. When NfcMessage that matches NfcWatchOptions is found, it is passed to NfcClient
+     * interface together with corresponding watch ID.
+     * @see NfcClient#onWatch(int[] id, NfcMessage message)
+     *
+     * @param options used to filter NfcMessages, @see NfcWatchOptions.
+     * @param callback that is used to notify caller when watch() is completed and return watch ID.
+     */
+    @Override
+    public void watch(NfcWatchOptions options, WatchResponse callback) {
+        if (!checkIfReady(callback)) return;
+        // TODO(shalamov): Not implemented.
+        callback.call(0, createError(NfcErrorType.NOT_SUPPORTED));
+    }
+
+    /**
+     * Cancels NFC watch operation.
+     *
+     * @param id of watch operation.
+     * @param callback that is used to notify caller when cancelWatch() is completed.
+     */
+    @Override
+    public void cancelWatch(int id, CancelWatchResponse callback) {
+        if (!checkIfReady(callback)) return;
+        // TODO(shalamov): Not implemented.
+        callback.call(createError(NfcErrorType.NOT_SUPPORTED));
+    }
+
+    /**
+     * Cancels all NFC watch operations.
+     *
+     * @param callback that is used to notify caller when cancelAllWatches() is completed.
+     */
+    @Override
+    public void cancelAllWatches(CancelAllWatchesResponse callback) {
+        if (!checkIfReady(callback)) return;
+        // TODO(shalamov): Not implemented.
+        callback.call(createError(NfcErrorType.NOT_SUPPORTED));
+    }
+
+    /**
+     * Suspends all pending operations. Should be called when web page visibility is lost.
+     */
+    @Override
+    public void suspendNfcOperations() {
+        disableReaderMode();
+    }
+
+    /**
+     * Resumes all pending watch / push operations. Should be called when web page becomes visible.
+     */
+    @Override
+    public void resumeNfcOperations() {
+        if (mPendingPushOperation != null) enableReaderMode();
+        // TODO(shalamov): check if there are active watchers.
+    }
+
+    @Override
+    public void close() {
+        disableReaderMode();
+    }
+
+    @Override
+    public void onConnectionError(MojoException e) {
+        close();
+    }
+
+    /**
+     * Holds information about pending push operation.
+     */
+    private static class PendingPushOperation {
+        public final NfcMessage nfcMessage;
+        public final NfcPushOptions nfcPushOptions;
+        private final PushResponse mPushResponseCallback;
+
+        public PendingPushOperation(
+                NfcMessage message, NfcPushOptions options, PushResponse callback) {
+            nfcMessage = message;
+            nfcPushOptions = options;
+            mPushResponseCallback = callback;
+        }
+
+        /**
+         * Completes pending push operation.
+         *
+         * @param error should be null when operation is completed successfully, otherwise,
+         * error object with corresponding NfcErrorType should be provided.
+         */
+        public void complete(NfcError error) {
+            if (mPushResponseCallback != null) mPushResponseCallback.call(error);
+        }
+    }
+
+    /**
+     * Helper method that creates NfcError object from NfcErrorType.
+     */
+    private NfcError createError(int errorType) {
+        NfcError error = new NfcError();
+        error.errorType = errorType;
+        return error;
+    }
+
+    /**
+     * Checks if NFC funcionality can be used by the mojo service. If permission to use NFC is
+     * granted and hardware is enabled, returns null.
+     */
+    @Nullable
+    private NfcError checkIfReady() {
+        if (!mHasPermission) {
+            return createError(NfcErrorType.SECURITY);
+        } else if (mNfcManager == null || mNfcAdapter == null) {
+            return createError(NfcErrorType.NOT_SUPPORTED);
+        } else if (!mNfcAdapter.isEnabled()) {
+            return createError(NfcErrorType.DEVICE_DISABLED);
+        }
+        return null;
+    }
+
+    /**
+     * Uses checkIfReady() method and if NFC cannot be used, calls mojo callback with NfcError.
+     *
+     * @param WatchResponse Callback that is provided to watch() method.
+     * @return boolean true if NFC functionality can be used, false otherwise.
+     */
+    private boolean checkIfReady(WatchResponse callback) {
+        NfcError error = checkIfReady();
+        if (error == null) return true;
+        callback.call(0, error);
+        return false;
+    }
+
+    /**
+     * Uses checkIfReady() method and if NFC cannot be used, calls mojo callback with NfcError.
+     *
+     * @param callback Generic callback that is provided to push(), cancelPush(),
+     * cancelWatch() and cancelAllWatches() methods.
+     * @return boolean true if NFC functionality can be used, false otherwise.
+     */
+    private boolean checkIfReady(Callbacks.Callback1<NfcError> callback) {
+        NfcError error = checkIfReady();
+        if (error == null) return true;
+        callback.call(error);
+        return false;
+    }
+
+    /**
+     * Implementation of android.nfc.NfcAdapter.ReaderCallback. Callback is called when NFC tag is
+     * discovered, Tag object is delegated to mojo service implementation method
+     * NfcImpl.onTagDiscovered().
+     */
+    @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);
+        }
+    }
+
+    /**
+     * Enables reader mode, allowing NFC device to read / write NFC tags.
+     * @see android.nfc.NfcAdapter#enableReaderMode
+     */
+    private void enableReaderMode() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) return;
+        if (mReaderCallbackHandler != null || mActivity == 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);
+    }
+
+    /**
+     * Disables reader mode.
+     * @see android.nfc.NfcAdapter#disableReaderMode
+     */
+    private void disableReaderMode() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) return;
+
+        mReaderCallbackHandler = null;
+        if (mActivity != null) {
+            mNfcAdapter.disableReaderMode(mActivity);
+        }
+    }
+
+    /**
+     * Completes pending push operation. On error, invalidates #mTagHandler.
+     */
+    private void pendingPushOperationCompleted(NfcError error) {
+        if (mPendingPushOperation != null) {
+            mPendingPushOperation.complete(error);
+            mPendingPushOperation = null;
+
+            // TODO(shalamov): When nfc.watch is implemented, disable reader mode
+            // only when there are no active watch operations.
+            disableReaderMode();
+        }
+
+        if (error != null) mTagHandler = null;
+    }
+
+    /**
+     * Checks whether there is a #mPendingPushOperation and writes data to NFC tag. In case of
+     * exception calls pendingPushOperationCompleted() with appropriate error object.
+     */
+    private void processPendingPushOperation() {
+        if (mTagHandler == null || mPendingPushOperation == null) return;
+
+        if (mTagHandler.isTagOutOfRange()) {
+            mTagHandler = null;
+            return;
+        }
+
+        try {
+            mTagHandler.connect();
+            mTagHandler.write(NfcTypeConverter.toNdefMessage(mPendingPushOperation.nfcMessage));
+            pendingPushOperationCompleted(null);
+            mTagHandler.close();
+        } catch (InvalidNfcMessageException 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));
+        }
+    }
+
+    /**
+     * Called by ReaderCallbackHandler when NFC tag is in proximity.
+     */
+    public void onTagDiscovered(Tag tag) {
+        mTagHandler = NfcTagHandler.create(tag);
+        processPendingPushOperation();
+    }
+}