src/com/android/bips/LocalDiscoverySession.java - platform/packages/services/BuiltInPrintService - Git at Google

 /*
  * 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;

 import android.print.PrintManager;
 import android.print.PrinterId;
 import android.print.PrinterInfo;
 import android.printservice.PrintServiceInfo;
 import android.printservice.PrinterDiscoverySession;
 import android.printservice.recommendation.RecommendationInfo;
 import android.util.ArrayMap;
 import android.util.ArraySet;
 import android.util.JsonReader;
 import android.util.JsonWriter;
 import android.util.Log;

 import com.android.bips.discovery.DiscoveredPrinter;
 import com.android.bips.discovery.Discovery;
 import com.android.bips.ipp.CapabilitiesCache;

 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 class LocalDiscoverySession extends PrinterDiscoverySession implements Discovery.Listener,
         PrintManager.PrintServiceRecommendationsChangeListener,
         PrintManager.PrintServicesChangeListener {
     private static final String TAG = LocalDiscoverySession.class.getSimpleName();
     private static final boolean DEBUG = false;

     // Printers are removed after not being seen for this long
     static final long PRINTER_EXPIRATION_MILLIS = 3000;

     private static final String KNOWN_GOOD_FILE = "knowngood.json";
     private static final int KNOWN_GOOD_MAX = 50;

     private final BuiltInPrintService mPrintService;
     private final CapabilitiesCache mCapabilitiesCache;
     private final Map<PrinterId, LocalPrinter> mPrinters = new HashMap<>();
     private final Set<PrinterId> mPriorityIds = new HashSet<>();
     private final Set<PrinterId> mTrackingIds = new HashSet<>();
     private final List<PrinterId> mKnownGood = new ArrayList<>();
     private Runnable mExpirePrinters;

     PrintManager mPrintManager;

     /** Package names of all currently enabled print services beside this one */
     private ArraySet<String> mEnabledServices = new ArraySet<>();

     /**
      * Address of printers that can be handled by print services, ordered by package name of the
      * print service. The print service might not be enabled. For that, look at
      * {@link #mEnabledServices}.
      *
      * <p>This print service only shows a printer if another print service does not show it.
      */
     private final ArrayMap<InetAddress, ArrayList<String>> mPrintersOfOtherService =
             new ArrayMap<>();

     LocalDiscoverySession(BuiltInPrintService service) {
         mPrintService = service;
         mCapabilitiesCache = service.getCapabilitiesCache();
         mPrintManager = mPrintService.getSystemService(PrintManager.class);
         loadKnownGood();
     }

     @Override
     public void onStartPrinterDiscovery(List<PrinterId> priorityList) {
         if (DEBUG) Log.d(TAG, "onStartPrinterDiscovery() " + priorityList);

         // Replace priority IDs with the current list.
         mPriorityIds.clear();
         mPriorityIds.addAll(priorityList);

         // Mark all known printers as "not found". They may return shortly or may expire
         mPrinters.values().forEach(LocalPrinter::notFound);
         monitorExpiredPrinters();

         mPrintService.getDiscovery().start(this);

         mPrintManager.addPrintServicesChangeListener(this, null);
         onPrintServicesChanged();

         mPrintManager.addPrintServiceRecommendationsChangeListener(this, null);
         onPrintServiceRecommendationsChanged();
     }

     @Override
     public void onStopPrinterDiscovery() {
         if (DEBUG) Log.d(TAG, "onStopPrinterDiscovery()");
         mPrintService.getDiscovery().stop(this);

         PrintManager printManager = mPrintService.getSystemService(PrintManager.class);
         printManager.removePrintServicesChangeListener(this);
         printManager.removePrintServiceRecommendationsChangeListener(this);

         if (mExpirePrinters != null) {
             mPrintService.getMainHandler().removeCallbacks(mExpirePrinters);
             mExpirePrinters = null;
         }
     }

     @Override
     public void onValidatePrinters(List<PrinterId> printerIds) {
         if (DEBUG) Log.d(TAG, "onValidatePrinters() " + printerIds);
     }

     @Override
     public void onStartPrinterStateTracking(final PrinterId printerId) {
         if (DEBUG) Log.d(TAG, "onStartPrinterStateTracking() " + printerId);
         LocalPrinter localPrinter = mPrinters.get(printerId);
         mTrackingIds.add(printerId);

         // We cannot track the printer yet; wait until it is discovered
         if (localPrinter == null || !localPrinter.isFound()) return;

         // Immediately request a refresh of capabilities
         localPrinter.requestCapabilities();
     }

     @Override
     public void onStopPrinterStateTracking(PrinterId printerId) {
         if (DEBUG) Log.d(TAG, "onStopPrinterStateTracking() " + printerId.getLocalId());
         mTrackingIds.remove(printerId);
     }

     @Override
     public void onDestroy() {
         if (DEBUG) Log.d(TAG, "onDestroy");
         saveKnownGood();
     }

     /**
      * A printer was found during discovery
      */
     @Override
     public void onPrinterFound(DiscoveredPrinter discoveredPrinter) {
         if (DEBUG) Log.d(TAG, "onPrinterFound() " + discoveredPrinter);
         if (isDestroyed()) {
             Log.w(TAG, "Destroyed; ignoring");
             return;
         }

         final PrinterId printerId = discoveredPrinter.getId(mPrintService);
         LocalPrinter localPrinter = mPrinters.get(printerId);
         if (localPrinter == null) {
             localPrinter = new LocalPrinter(mPrintService, this, discoveredPrinter);
             mPrinters.put(printerId, localPrinter);
         }
         localPrinter.found();
     }

     /**
      * A printer was lost during discovery
      */
     @Override
     public void onPrinterLost(DiscoveredPrinter lostPrinter) {
         if (DEBUG) Log.d(TAG, "onPrinterLost() " + lostPrinter);

         PrinterId printerId = lostPrinter.getId(mPrintService);
         if (printerId.getLocalId().startsWith("ipp")) {
             // Forget capabilities for network addresses (which are not globally unique)
             mCapabilitiesCache.remove(lostPrinter.getUri());
         }

         LocalPrinter localPrinter = mPrinters.get(printerId);
         if (localPrinter == null) return;

         localPrinter.notFound();
         handlePrinter(localPrinter);
         monitorExpiredPrinters();
     }

     private void monitorExpiredPrinters() {
         if (mExpirePrinters == null && !mPrinters.isEmpty()) {
             mExpirePrinters = new ExpirePrinters();
             mPrintService.getMainHandler().postDelayed(mExpirePrinters, PRINTER_EXPIRATION_MILLIS);
         }
     }

     /** A complete printer record is available */
     void handlePrinter(LocalPrinter localPrinter) {
         if (localPrinter.getCapabilities() == null &&
                 !mKnownGood.contains(localPrinter.getPrinterId())) {
             // Ignore printers that have no capabilities and are not known-good
             return;
         }

         PrinterInfo info = localPrinter.createPrinterInfo();

         mKnownGood.remove(localPrinter.getPrinterId());

         if (info == null) return;

         // Update known-good database with current results.
         if (info.getStatus() == PrinterInfo.STATUS_IDLE && localPrinter.getUuid() != null) {
             // Mark UUID-based printers with IDLE status as known-good
             mKnownGood.add(0, localPrinter.getPrinterId());
         }

         for (PrinterInfo knownInfo : getPrinters()) {
             if (knownInfo.getId().equals(info.getId()) && (info.getCapabilities() == null)) {
                 if (DEBUG) Log.d(TAG, "Ignore update with no caps " + localPrinter);
                 return;
             }
         }

         if (DEBUG) {
             Log.d(TAG, "handlePrinter: reporting " + localPrinter +
                     " caps=" + (info.getCapabilities() != null) + " status=" + info.getStatus());
         }

         if (!isHandledByOtherService(localPrinter)) {
             addPrinters(Collections.singletonList(info));
         }
     }

     /**
      * Return true if the {@link PrinterId} corresponds to a high-priority printer
      */
     boolean isPriority(PrinterId printerId) {
         return mTrackingIds.contains(printerId);
     }

     /**
      * Return true if the {@link PrinterId} corresponds to a known printer
      */
     boolean isKnown(PrinterId printerId) {
         return mPrinters.containsKey(printerId);
     }

     /**
      * Load "known good" printer IDs from storage, if possible
      */
     private void loadKnownGood() {
         File file = new File(mPrintService.getCacheDir(), KNOWN_GOOD_FILE);
         if (!file.exists()) return;
         try (JsonReader reader = new JsonReader(new FileReader(file))) {
             reader.beginArray();
             while (reader.hasNext()) {
                 String localId = reader.nextString();
                 mKnownGood.add(mPrintService.generatePrinterId(localId));
             }
             reader.endArray();
         } catch (IOException e) {
             Log.w(TAG, "Failed to read known good list", e);
         }
     }

     /**
      * Save "known good" printer IDs to storage, if possible
      */
     private void saveKnownGood() {
         File file = new File(mPrintService.getCacheDir(), KNOWN_GOOD_FILE);
         try (JsonWriter writer = new JsonWriter(new FileWriter(file))) {
             writer.beginArray();
             for (int i = 0; i < Math.min(KNOWN_GOOD_MAX, mKnownGood.size()); i++) {
                 writer.value(mKnownGood.get(i).getLocalId());
             }
             writer.endArray();
         } catch (IOException e) {
             Log.w(TAG, "Failed to write known good list", e);
         }
     }

     /**
      * Is this printer handled by another print service and should be suppressed?
      *
      * @param printer The printer that might need to be suppressed
      *
      * @return {@code true} iff the printer should be suppressed
      */
     private boolean isHandledByOtherService(LocalPrinter printer) {
         InetAddress address = printer.getAddress();
         if (address == null) return false;

         ArrayList<String> printerServices = mPrintersOfOtherService.get(printer.getAddress());

         if (printerServices != null) {
             int numServices = printerServices.size();
             for (int i = 0; i < numServices; i++) {
                 if (mEnabledServices.contains(printerServices.get(i))) {
                     return true;
                 }
             }
         }

         return false;
     }

     /**
      * If the system's print service state changed some printer might be newly suppressed or not
      * suppressed anymore.
      */
     private void onPrintServicesStateUpdated() {
         ArrayList<PrinterInfo> printersToAdd = new ArrayList<>();
         ArrayList<PrinterId> printersToRemove = new ArrayList<>();
         for (LocalPrinter printer : mPrinters.values()) {
             PrinterInfo info = printer.createPrinterInfo();

             if (printer.getCapabilities() != null && printer.isFound()
                     && !isHandledByOtherService(printer) && info != null) {
                 printersToAdd.add(info);
             } else {
                 printersToRemove.add(printer.getPrinterId());
             }
         }

         removePrinters(printersToRemove);
         addPrinters(printersToAdd);
     }

     @Override
     public void onPrintServiceRecommendationsChanged() {
         mPrintersOfOtherService.clear();

         List<RecommendationInfo> infos = mPrintManager.getPrintServiceRecommendations();

         int numInfos = infos.size();
         for (int i = 0; i < numInfos; i++) {
             RecommendationInfo info = infos.get(i);
             String packageName = info.getPackageName().toString();

             if (!packageName.equals(mPrintService.getPackageName())) {
                 for (InetAddress address : info.getDiscoveredPrinters()) {
                     ArrayList<String> services = mPrintersOfOtherService.get(address);

                     if (services == null) {
                         services = new ArrayList<>(1);
                         mPrintersOfOtherService.put(address, services);
                     }

                     services.add(packageName);
                 }
             }
         }

         onPrintServicesStateUpdated();
     }

     @Override
     public void onPrintServicesChanged() {
         mEnabledServices.clear();

         List<PrintServiceInfo> infos = mPrintManager.getPrintServices(
                 PrintManager.ENABLED_SERVICES);

         int numInfos = infos.size();
         for (int i = 0; i < numInfos; i++) {
             PrintServiceInfo info = infos.get(i);
             String packageName = info.getComponentName().getPackageName();

             if (!packageName.equals(mPrintService.getPackageName())) {
                 mEnabledServices.add(packageName);
             }
         }

         onPrintServicesStateUpdated();
     }

     /** A runnable that periodically removes expired printers, when any exist */
     private class ExpirePrinters implements Runnable {
         @Override
         public void run() {
             boolean allFound = true;
             List<PrinterId> idsToRemove = new ArrayList<>();

             for (LocalPrinter localPrinter : mPrinters.values()) {
                 if (localPrinter.isExpired()) {
                     if (DEBUG) Log.d(TAG, "Expiring " + localPrinter);
                     idsToRemove.add(localPrinter.getPrinterId());
                 }
                 if (!localPrinter.isFound()) allFound = false;
             }
             idsToRemove.forEach(mPrinters::remove);
             removePrinters(idsToRemove);
             if (!allFound) {
                 mPrintService.getMainHandler().postDelayed(this, PRINTER_EXPIRATION_MILLIS);
             } else {
                 mExpirePrinters = null;
             }
         }
     }
 }
	/*
	* 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;

	import android.print.PrintManager;
	import android.print.PrinterId;
	import android.print.PrinterInfo;
	import android.printservice.PrintServiceInfo;
	import android.printservice.PrinterDiscoverySession;
	import android.printservice.recommendation.RecommendationInfo;
	import android.util.ArrayMap;
	import android.util.ArraySet;
	import android.util.JsonReader;
	import android.util.JsonWriter;
	import android.util.Log;

	import com.android.bips.discovery.DiscoveredPrinter;
	import com.android.bips.discovery.Discovery;
	import com.android.bips.ipp.CapabilitiesCache;

	import java.io.File;
	import java.io.FileReader;
	import java.io.FileWriter;
	import java.io.IOException;
	import java.net.InetAddress;
	import java.net.UnknownHostException;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	class LocalDiscoverySession extends PrinterDiscoverySession implements Discovery.Listener,
	PrintManager.PrintServiceRecommendationsChangeListener,
	PrintManager.PrintServicesChangeListener {
	private static final String TAG = LocalDiscoverySession.class.getSimpleName();
	private static final boolean DEBUG = false;

	// Printers are removed after not being seen for this long
	static final long PRINTER_EXPIRATION_MILLIS = 3000;

	private static final String KNOWN_GOOD_FILE = "knowngood.json";
	private static final int KNOWN_GOOD_MAX = 50;

	private final BuiltInPrintService mPrintService;
	private final CapabilitiesCache mCapabilitiesCache;
	private final Map<PrinterId, LocalPrinter> mPrinters = new HashMap<>();
	private final Set<PrinterId> mPriorityIds = new HashSet<>();
	private final Set<PrinterId> mTrackingIds = new HashSet<>();
	private final List<PrinterId> mKnownGood = new ArrayList<>();
	private Runnable mExpirePrinters;

	PrintManager mPrintManager;

	/** Package names of all currently enabled print services beside this one */
	private ArraySet<String> mEnabledServices = new ArraySet<>();

	/**
	* Address of printers that can be handled by print services, ordered by package name of the
	* print service. The print service might not be enabled. For that, look at
	* {@link #mEnabledServices}.
	*
	* <p>This print service only shows a printer if another print service does not show it.
	*/
	private final ArrayMap<InetAddress, ArrayList<String>> mPrintersOfOtherService =
	new ArrayMap<>();

	LocalDiscoverySession(BuiltInPrintService service) {
	mPrintService = service;
	mCapabilitiesCache = service.getCapabilitiesCache();
	mPrintManager = mPrintService.getSystemService(PrintManager.class);
	loadKnownGood();
	}

	@Override
	public void onStartPrinterDiscovery(List<PrinterId> priorityList) {
	if (DEBUG) Log.d(TAG, "onStartPrinterDiscovery() " + priorityList);

	// Replace priority IDs with the current list.
	mPriorityIds.clear();
	mPriorityIds.addAll(priorityList);

	// Mark all known printers as "not found". They may return shortly or may expire
	mPrinters.values().forEach(LocalPrinter::notFound);
	monitorExpiredPrinters();

	mPrintService.getDiscovery().start(this);

	mPrintManager.addPrintServicesChangeListener(this, null);
	onPrintServicesChanged();

	mPrintManager.addPrintServiceRecommendationsChangeListener(this, null);
	onPrintServiceRecommendationsChanged();
	}

	@Override
	public void onStopPrinterDiscovery() {
	if (DEBUG) Log.d(TAG, "onStopPrinterDiscovery()");
	mPrintService.getDiscovery().stop(this);

	PrintManager printManager = mPrintService.getSystemService(PrintManager.class);
	printManager.removePrintServicesChangeListener(this);
	printManager.removePrintServiceRecommendationsChangeListener(this);

	if (mExpirePrinters != null) {
	mPrintService.getMainHandler().removeCallbacks(mExpirePrinters);
	mExpirePrinters = null;
	}
	}

	@Override
	public void onValidatePrinters(List<PrinterId> printerIds) {
	if (DEBUG) Log.d(TAG, "onValidatePrinters() " + printerIds);
	}

	@Override
	public void onStartPrinterStateTracking(final PrinterId printerId) {
	if (DEBUG) Log.d(TAG, "onStartPrinterStateTracking() " + printerId);
	LocalPrinter localPrinter = mPrinters.get(printerId);
	mTrackingIds.add(printerId);

	// We cannot track the printer yet; wait until it is discovered
	if (localPrinter == null \|\| !localPrinter.isFound()) return;

	// Immediately request a refresh of capabilities
	localPrinter.requestCapabilities();
	}

	@Override
	public void onStopPrinterStateTracking(PrinterId printerId) {
	if (DEBUG) Log.d(TAG, "onStopPrinterStateTracking() " + printerId.getLocalId());
	mTrackingIds.remove(printerId);
	}

	@Override
	public void onDestroy() {
	if (DEBUG) Log.d(TAG, "onDestroy");
	saveKnownGood();
	}

	/**
	* A printer was found during discovery
	*/
	@Override
	public void onPrinterFound(DiscoveredPrinter discoveredPrinter) {
	if (DEBUG) Log.d(TAG, "onPrinterFound() " + discoveredPrinter);
	if (isDestroyed()) {
	Log.w(TAG, "Destroyed; ignoring");
	return;
	}

	final PrinterId printerId = discoveredPrinter.getId(mPrintService);
	LocalPrinter localPrinter = mPrinters.get(printerId);
	if (localPrinter == null) {
	localPrinter = new LocalPrinter(mPrintService, this, discoveredPrinter);
	mPrinters.put(printerId, localPrinter);
	}
	localPrinter.found();
	}

	/**
	* A printer was lost during discovery
	*/
	@Override
	public void onPrinterLost(DiscoveredPrinter lostPrinter) {
	if (DEBUG) Log.d(TAG, "onPrinterLost() " + lostPrinter);

	PrinterId printerId = lostPrinter.getId(mPrintService);
	if (printerId.getLocalId().startsWith("ipp")) {
	// Forget capabilities for network addresses (which are not globally unique)
	mCapabilitiesCache.remove(lostPrinter.getUri());
	}

	LocalPrinter localPrinter = mPrinters.get(printerId);
	if (localPrinter == null) return;

	localPrinter.notFound();
	handlePrinter(localPrinter);
	monitorExpiredPrinters();
	}

	private void monitorExpiredPrinters() {
	if (mExpirePrinters == null && !mPrinters.isEmpty()) {
	mExpirePrinters = new ExpirePrinters();
	mPrintService.getMainHandler().postDelayed(mExpirePrinters, PRINTER_EXPIRATION_MILLIS);
	}
	}

	/** A complete printer record is available */
	void handlePrinter(LocalPrinter localPrinter) {
	if (localPrinter.getCapabilities() == null &&
	!mKnownGood.contains(localPrinter.getPrinterId())) {
	// Ignore printers that have no capabilities and are not known-good
	return;
	}

	PrinterInfo info = localPrinter.createPrinterInfo();

	mKnownGood.remove(localPrinter.getPrinterId());

	if (info == null) return;

	// Update known-good database with current results.
	if (info.getStatus() == PrinterInfo.STATUS_IDLE && localPrinter.getUuid() != null) {
	// Mark UUID-based printers with IDLE status as known-good
	mKnownGood.add(0, localPrinter.getPrinterId());
	}

	for (PrinterInfo knownInfo : getPrinters()) {
	if (knownInfo.getId().equals(info.getId()) && (info.getCapabilities() == null)) {
	if (DEBUG) Log.d(TAG, "Ignore update with no caps " + localPrinter);
	return;
	}
	}

	if (DEBUG) {
	Log.d(TAG, "handlePrinter: reporting " + localPrinter +
	" caps=" + (info.getCapabilities() != null) + " status=" + info.getStatus());
	}

	if (!isHandledByOtherService(localPrinter)) {
	addPrinters(Collections.singletonList(info));
	}
	}

	/**
	* Return true if the {@link PrinterId} corresponds to a high-priority printer
	*/
	boolean isPriority(PrinterId printerId) {
	return mTrackingIds.contains(printerId);
	}

	/**
	* Return true if the {@link PrinterId} corresponds to a known printer
	*/
	boolean isKnown(PrinterId printerId) {
	return mPrinters.containsKey(printerId);
	}

	/**
	* Load "known good" printer IDs from storage, if possible
	*/
	private void loadKnownGood() {
	File file = new File(mPrintService.getCacheDir(), KNOWN_GOOD_FILE);
	if (!file.exists()) return;
	try (JsonReader reader = new JsonReader(new FileReader(file))) {
	reader.beginArray();
	while (reader.hasNext()) {
	String localId = reader.nextString();
	mKnownGood.add(mPrintService.generatePrinterId(localId));
	}
	reader.endArray();
	} catch (IOException e) {
	Log.w(TAG, "Failed to read known good list", e);
	}
	}

	/**
	* Save "known good" printer IDs to storage, if possible
	*/
	private void saveKnownGood() {
	File file = new File(mPrintService.getCacheDir(), KNOWN_GOOD_FILE);
	try (JsonWriter writer = new JsonWriter(new FileWriter(file))) {
	writer.beginArray();
	for (int i = 0; i < Math.min(KNOWN_GOOD_MAX, mKnownGood.size()); i++) {
	writer.value(mKnownGood.get(i).getLocalId());
	}
	writer.endArray();
	} catch (IOException e) {
	Log.w(TAG, "Failed to write known good list", e);
	}
	}

	/**
	* Is this printer handled by another print service and should be suppressed?
	*
	* @param printer The printer that might need to be suppressed
	*
	* @return {@code true} iff the printer should be suppressed
	*/
	private boolean isHandledByOtherService(LocalPrinter printer) {
	InetAddress address = printer.getAddress();
	if (address == null) return false;

	ArrayList<String> printerServices = mPrintersOfOtherService.get(printer.getAddress());

	if (printerServices != null) {
	int numServices = printerServices.size();
	for (int i = 0; i < numServices; i++) {
	if (mEnabledServices.contains(printerServices.get(i))) {
	return true;
	}
	}
	}

	return false;
	}

	/**
	* If the system's print service state changed some printer might be newly suppressed or not
	* suppressed anymore.
	*/
	private void onPrintServicesStateUpdated() {
	ArrayList<PrinterInfo> printersToAdd = new ArrayList<>();
	ArrayList<PrinterId> printersToRemove = new ArrayList<>();
	for (LocalPrinter printer : mPrinters.values()) {
	PrinterInfo info = printer.createPrinterInfo();

	if (printer.getCapabilities() != null && printer.isFound()
	&& !isHandledByOtherService(printer) && info != null) {
	printersToAdd.add(info);
	} else {
	printersToRemove.add(printer.getPrinterId());
	}
	}

	removePrinters(printersToRemove);
	addPrinters(printersToAdd);
	}

	@Override
	public void onPrintServiceRecommendationsChanged() {
	mPrintersOfOtherService.clear();

	List<RecommendationInfo> infos = mPrintManager.getPrintServiceRecommendations();

	int numInfos = infos.size();
	for (int i = 0; i < numInfos; i++) {
	RecommendationInfo info = infos.get(i);
	String packageName = info.getPackageName().toString();

	if (!packageName.equals(mPrintService.getPackageName())) {
	for (InetAddress address : info.getDiscoveredPrinters()) {
	ArrayList<String> services = mPrintersOfOtherService.get(address);

	if (services == null) {
	services = new ArrayList<>(1);
	mPrintersOfOtherService.put(address, services);
	}

	services.add(packageName);
	}
	}
	}

	onPrintServicesStateUpdated();
	}

	@Override
	public void onPrintServicesChanged() {
	mEnabledServices.clear();

	List<PrintServiceInfo> infos = mPrintManager.getPrintServices(
	PrintManager.ENABLED_SERVICES);

	int numInfos = infos.size();
	for (int i = 0; i < numInfos; i++) {
	PrintServiceInfo info = infos.get(i);
	String packageName = info.getComponentName().getPackageName();

	if (!packageName.equals(mPrintService.getPackageName())) {
	mEnabledServices.add(packageName);
	}
	}

	onPrintServicesStateUpdated();
	}

	/** A runnable that periodically removes expired printers, when any exist */
	private class ExpirePrinters implements Runnable {
	@Override
	public void run() {
	boolean allFound = true;
	List<PrinterId> idsToRemove = new ArrayList<>();

	for (LocalPrinter localPrinter : mPrinters.values()) {
	if (localPrinter.isExpired()) {
	if (DEBUG) Log.d(TAG, "Expiring " + localPrinter);
	idsToRemove.add(localPrinter.getPrinterId());
	}
	if (!localPrinter.isFound()) allFound = false;
	}
	idsToRemove.forEach(mPrinters::remove);
	removePrinters(idsToRemove);
	if (!allFound) {
	mPrintService.getMainHandler().postDelayed(this, PRINTER_EXPIRATION_MILLIS);
	} else {
	mExpirePrinters = null;
	}
	}
	}
	}