Home | History | Annotate | Download | only in print 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.print;
     18 
     19 import android.annotation.NonNull;
     20 import android.content.Context;
     21 import android.content.Loader;
     22 import android.os.Handler;
     23 import android.os.Message;
     24 import android.printservice.PrintServiceInfo;
     25 
     26 import com.android.internal.util.Preconditions;
     27 
     28 import java.util.List;
     29 
     30 /**
     31  * Loader for the list of print services. Can be parametrized to select a subset.
     32  *
     33  * @hide
     34  */
     35 public class PrintServicesLoader extends Loader<List<PrintServiceInfo>> {
     36     /** What type of services to load. */
     37     private final int mSelectionFlags;
     38 
     39     /** The print manager to be used by this object */
     40     private final @NonNull PrintManager mPrintManager;
     41 
     42     /** Handler to sequentialize the delivery of the results to the main thread */
     43     private final @NonNull Handler mHandler;
     44 
     45     /** Listens for updates to the data from the platform */
     46     private PrintManager.PrintServicesChangeListener mListener;
     47 
     48     /**
     49      * Create a new PrintServicesLoader.
     50      *
     51      * @param printManager   The print manager supplying the data
     52      * @param context        Context of the using object
     53      * @param selectionFlags What type of services to load.
     54      */
     55     public PrintServicesLoader(@NonNull PrintManager printManager, @NonNull Context context,
     56             int selectionFlags) {
     57         super(Preconditions.checkNotNull(context));
     58         mHandler = new MyHandler();
     59         mPrintManager = Preconditions.checkNotNull(printManager);
     60         mSelectionFlags = Preconditions.checkFlagsArgument(selectionFlags,
     61                 PrintManager.ALL_SERVICES);
     62     }
     63 
     64     @Override
     65     protected void onForceLoad() {
     66         queueNewResult();
     67     }
     68 
     69     /**
     70      * Read the print services and queue it to be delivered on the main thread.
     71      */
     72     private void queueNewResult() {
     73         Message m = mHandler.obtainMessage(0);
     74         m.obj = mPrintManager.getPrintServices(mSelectionFlags);
     75         mHandler.sendMessage(m);
     76     }
     77 
     78     @Override
     79     protected void onStartLoading() {
     80         mListener = new PrintManager.PrintServicesChangeListener() {
     81             @Override public void onPrintServicesChanged() {
     82                 queueNewResult();
     83             }
     84         };
     85 
     86         mPrintManager.addPrintServicesChangeListener(mListener, null);
     87 
     88         // Immediately deliver a result
     89         deliverResult(mPrintManager.getPrintServices(mSelectionFlags));
     90     }
     91 
     92     @Override
     93     protected void onStopLoading() {
     94         if (mListener != null) {
     95             mPrintManager.removePrintServicesChangeListener(mListener);
     96             mListener = null;
     97         }
     98 
     99         mHandler.removeMessages(0);
    100     }
    101 
    102     @Override
    103     protected void onReset() {
    104         onStopLoading();
    105     }
    106 
    107     /**
    108      * Handler to sequentialize all the updates to the main thread.
    109      */
    110     private class MyHandler extends Handler {
    111         /**
    112          * Create a new handler on the main thread.
    113          */
    114         public MyHandler() {
    115             super(getContext().getMainLooper());
    116         }
    117 
    118         @Override
    119         public void handleMessage(Message msg) {
    120             if (isStarted()) {
    121                 deliverResult((List<PrintServiceInfo>) msg.obj);
    122             }
    123         }
    124     }
    125 }
    126