src/com/android/bips/discovery/ManualDiscovery.java

/*
 * Copyright (C) 2016 The Android Open Source Project
 * Copyright (C) 2016 Mopria Alliance, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.bips.discovery;

import android.net.Uri;
import android.text.TextUtils;
import android.util.Log;

import com.android.bips.BuiltInPrintService;
import com.android.bips.ipp.CapabilitiesCache;
import com.android.bips.jni.LocalPrinterCapabilities;
import com.android.bips.util.WifiMonitor;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

/**
 * Manage a list of printers manually added by the user.
 */
public class ManualDiscovery extends SavedDiscovery {
    private static final String TAG = ManualDiscovery.class.getSimpleName();
    private static final boolean DEBUG = false;

    // Likely paths at which a print service may be found
    private static final Uri[] IPP_URIS = {Uri.parse("ipp://host:631/ipp/print"),
            Uri.parse("ipp://host:80/ipp/print"), Uri.parse("ipp://host:631/ipp/printer"),
            Uri.parse("ipp://host:631/ipp"), Uri.parse("ipp://host:631/"),
            Uri.parse("ipps://host:631/ipp/print"), Uri.parse("ipps://host:443/ipp/print"),
            Uri.parse("ipps://host:10443/ipp/print")};

    private WifiMonitor mWifiMonitor;
    private CapabilitiesCache mCapabilitiesCache;
    private List<CapabilitiesFinder> mAddRequests = new ArrayList<>();

    public ManualDiscovery(BuiltInPrintService printService) {
        super(printService);
        mCapabilitiesCache = getPrintService().getCapabilitiesCache();
    }

    @Override
    void onStart() {
        if (DEBUG) Log.d(TAG, "onStart");

        // Upon any network change scan for all manually added printers
        mWifiMonitor = new WifiMonitor(getPrintService(), isConnected -> {
            if (isConnected) {
                for (DiscoveredPrinter printer : getSavedPrinters()) {
                    mCapabilitiesCache.request(printer, false, capabilities -> {
                        if (capabilities != null) {
                            printerFound(printer);
                        }
                    });
                }
            } else {
                allPrintersLost();
            }
        });
    }

    @Override
    void onStop() {
        if (DEBUG) Log.d(TAG, "onStop");
        mWifiMonitor.close();
        allPrintersLost();
    }

    /**
     * Asynchronously attempt to add a new manual printer, calling back with success if
     * printer capabilities were discovered.
     *
     * The supplied URI must include a hostname and may also include a scheme (either ipp:// or
     * ipps://), a port (such as :443), and/or a path (like /ipp/print). If any parts are missing,
     * typical known values are substituted and searched until success is found, or all are
     * tried unsuccessfully.
     *
     * @param printerUri URI to search
     */
    public void addManualPrinter(Uri printerUri, PrinterAddCallback callback) {
        if (DEBUG) Log.d(TAG, "addManualPrinter " + printerUri);

        int givenPort = printerUri.getPort();
        String givenPath = printerUri.getPath();
        String hostname = printerUri.getHost();
        String givenScheme = printerUri.getScheme();

        // Use LinkedHashSet to eliminate duplicates but maintain order
        Set<Uri> uris = new LinkedHashSet<>();
        for (Uri uri : IPP_URIS) {
            String scheme = uri.getScheme();
            if (!TextUtils.isEmpty(givenScheme) && !scheme.equals(givenScheme)) {
                // If scheme was supplied and doesn't match this uri template, skip
                continue;
            }
            String authority = hostname + ":" + (givenPort == -1 ? uri.getPort() : givenPort);
            String path = TextUtils.isEmpty(givenPath) ? uri.getPath() : givenPath;
            Uri targetUri = uri.buildUpon().scheme(scheme).encodedAuthority(authority).path(path)
                    .build();
            uris.add(targetUri);
        }

        mAddRequests.add(new CapabilitiesFinder(uris, callback));
    }

    /**
     * Cancel a prior {@link #addManualPrinter(Uri, PrinterAddCallback)} attempt having the same
     * callback
     */
    public void cancelAddManualPrinter(PrinterAddCallback callback) {
        for (CapabilitiesFinder finder : mAddRequests) {
            if (finder.mFinalCallback == callback) {
                mAddRequests.remove(finder);
                finder.cancel();
                return;
            }
        }
    }

    /** Used to convey response to {@link #addManualPrinter} */
    public interface PrinterAddCallback {
        /**
         * The requested manual printer was found.
         *
         * @param printer   information about the discovered printer
         * @param supported true if the printer is supported (and was therefore added), or false
         *                  if the printer was found but is not supported (and was therefore not
         *                  added)
         */
        void onFound(DiscoveredPrinter printer, boolean supported);

        /**
         * The requested manual printer was not found.
         */
        void onNotFound();
    }

    /**
     * Search common printer paths for a successful response
     */
    private class CapabilitiesFinder {
        private final PrinterAddCallback mFinalCallback;
        private final List<CapabilitiesCache.OnLocalPrinterCapabilities> mRequests =
                new ArrayList<>();

        /**
         * Constructs a new finder
         *
         * @param uris     Locations to check for IPP endpoints
         * @param callback Callback to issue when the first successful response arrives, or
         *                 when all responses have failed.
         */
        CapabilitiesFinder(Collection<Uri> uris, PrinterAddCallback callback) {
            mFinalCallback = callback;
            for (Uri uri : uris) {
                CapabilitiesCache.OnLocalPrinterCapabilities capabilitiesCallback =
                        new CapabilitiesCache.OnLocalPrinterCapabilities() {
                            @Override
                            public void onCapabilities(LocalPrinterCapabilities capabilities) {
                                mRequests.remove(this);
                                handleCapabilities(uri, capabilities);
                            }
                        };
                mRequests.add(capabilitiesCallback);

                // Force a clean attempt from scratch
                mCapabilitiesCache.remove(uri);
                mCapabilitiesCache.request(new DiscoveredPrinter(null, "", uri, null),
                        true, capabilitiesCallback);
            }
        }

        /** Capabilities have arrived (or not) for the printer at a given path */
        void handleCapabilities(Uri printerPath, LocalPrinterCapabilities capabilities) {
            if (DEBUG) Log.d(TAG, "request " + printerPath + " cap=" + capabilities);

            if (capabilities == null) {
                if (mRequests.isEmpty()) {
                    mAddRequests.remove(this);
                    mFinalCallback.onNotFound();
                }
                return;
            }

            // Success, so cancel all other requests
            for (CapabilitiesCache.OnLocalPrinterCapabilities request : mRequests) {
                mCapabilitiesCache.cancel(request);
            }
            mRequests.clear();

            // Deliver a successful response
            Uri uuid = TextUtils.isEmpty(capabilities.uuid) ? null : Uri.parse(capabilities.uuid);
            String name = TextUtils.isEmpty(capabilities.name) ? printerPath.getHost()
                    : capabilities.name;

            DiscoveredPrinter resolvedPrinter = new DiscoveredPrinter(uuid, name, printerPath,
                    capabilities.location);

            // Only add supported printers
            if (capabilities.isSupported) {
                if (addSavedPrinter(resolvedPrinter)) {
                    printerFound(resolvedPrinter);
                }
            }
            mAddRequests.remove(this);
            mFinalCallback.onFound(resolvedPrinter, capabilities.isSupported);
        }

        /** Stop all in-progress capability requests that are in progress */
        public void cancel() {
            for (CapabilitiesCache.OnLocalPrinterCapabilities callback : mRequests) {
                mCapabilitiesCache.cancel(callback);
            }
            mRequests.clear();
        }
    }
}