| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * 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.printspooler.ui; |
| |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.app.Activity; |
| import android.app.LoaderManager; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentSender.SendIntentException; |
| import android.content.Loader; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.PackageManager; |
| import android.database.DataSetObserver; |
| import android.graphics.drawable.Drawable; |
| import android.os.Build; |
| import android.os.Bundle; |
| import android.print.PrintManager; |
| import android.print.PrintServicesLoader; |
| import android.print.PrinterId; |
| import android.print.PrinterInfo; |
| import android.printservice.PrintService; |
| import android.printservice.PrintServiceInfo; |
| import android.provider.Settings; |
| import android.text.TextUtils; |
| import android.util.ArrayMap; |
| import android.util.Log; |
| import android.util.TypedValue; |
| import android.view.ContextMenu; |
| import android.view.ContextMenu.ContextMenuInfo; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.View; |
| import android.view.View.OnClickListener; |
| import android.view.ViewGroup; |
| import android.view.accessibility.AccessibilityManager; |
| import android.widget.AdapterView; |
| import android.widget.AdapterView.AdapterContextMenuInfo; |
| import android.widget.BaseAdapter; |
| import android.widget.Filter; |
| import android.widget.Filterable; |
| import android.widget.ImageView; |
| import android.widget.LinearLayout; |
| import android.widget.ListView; |
| import android.widget.SearchView; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| |
| import com.android.internal.logging.MetricsLogger; |
| import com.android.internal.logging.nano.MetricsProto.MetricsEvent; |
| import com.android.printspooler.R; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * This is an activity for selecting a printer. |
| */ |
| public final class SelectPrinterActivity extends Activity implements |
| LoaderManager.LoaderCallbacks<List<PrintServiceInfo>> { |
| |
| private static final String LOG_TAG = "SelectPrinterFragment"; |
| |
| private static final int LOADER_ID_PRINT_REGISTRY = 1; |
| private static final int LOADER_ID_PRINT_REGISTRY_INT = 2; |
| private static final int LOADER_ID_ENABLED_PRINT_SERVICES = 3; |
| |
| private static final int INFO_INTENT_REQUEST_CODE = 1; |
| |
| public static final String INTENT_EXTRA_PRINTER = "INTENT_EXTRA_PRINTER"; |
| |
| private static final String EXTRA_PRINTER = "EXTRA_PRINTER"; |
| private static final String EXTRA_PRINTER_ID = "EXTRA_PRINTER_ID"; |
| |
| private static final String KEY_NOT_FIRST_CREATE = "KEY_NOT_FIRST_CREATE"; |
| private static final String KEY_DID_SEARCH = "DID_SEARCH"; |
| private static final String KEY_PRINTER_FOR_INFO_INTENT = "KEY_PRINTER_FOR_INFO_INTENT"; |
| |
| // Constants for MetricsLogger.count and MetricsLogger.histo |
| private static final String PRINTERS_LISTED_COUNT = "printers_listed"; |
| private static final String PRINTERS_ICON_COUNT = "printers_icon"; |
| private static final String PRINTERS_INFO_COUNT = "printers_info"; |
| |
| /** The currently enabled print services by their ComponentName */ |
| private ArrayMap<ComponentName, PrintServiceInfo> mEnabledPrintServices; |
| |
| private PrinterRegistry mPrinterRegistry; |
| |
| private ListView mListView; |
| |
| private AnnounceFilterResult mAnnounceFilterResult; |
| |
| private boolean mDidSearch; |
| |
| /** |
| * Printer we are currently in the info intent for. This is only non-null while this activity |
| * started an info intent that has not yet returned |
| */ |
| private @Nullable PrinterInfo mPrinterForInfoIntent; |
| |
| private void startAddPrinterActivity() { |
| MetricsLogger.action(this, MetricsEvent.ACTION_PRINT_SERVICE_ADD); |
| startActivity(new Intent(this, AddPrinterActivity.class)); |
| } |
| |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| getActionBar().setIcon(com.android.internal.R.drawable.ic_print); |
| |
| setContentView(R.layout.select_printer_activity); |
| |
| getActionBar().setDisplayHomeAsUpEnabled(true); |
| |
| mEnabledPrintServices = new ArrayMap<>(); |
| |
| mPrinterRegistry = new PrinterRegistry(this, null, LOADER_ID_PRINT_REGISTRY, |
| LOADER_ID_PRINT_REGISTRY_INT); |
| |
| // Hook up the list view. |
| mListView = findViewById(android.R.id.list); |
| final DestinationAdapter adapter = new DestinationAdapter(); |
| adapter.registerDataSetObserver(new DataSetObserver() { |
| @Override |
| public void onChanged() { |
| if (!isFinishing() && adapter.getCount() <= 0) { |
| updateEmptyView(adapter); |
| } |
| } |
| |
| @Override |
| public void onInvalidated() { |
| if (!isFinishing()) { |
| updateEmptyView(adapter); |
| } |
| } |
| }); |
| mListView.setAdapter(adapter); |
| |
| mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() { |
| @Override |
| public void onItemClick(AdapterView<?> parent, View view, int position, long id) { |
| if (!((DestinationAdapter) mListView.getAdapter()).isActionable(position)) { |
| return; |
| } |
| |
| PrinterInfo printer = (PrinterInfo) mListView.getAdapter().getItem(position); |
| |
| if (printer == null) { |
| startAddPrinterActivity(); |
| } else { |
| onPrinterSelected(printer); |
| } |
| } |
| }); |
| |
| findViewById(R.id.button).setOnClickListener(new OnClickListener() { |
| @Override public void onClick(View v) { |
| startAddPrinterActivity(); |
| } |
| }); |
| |
| registerForContextMenu(mListView); |
| |
| getLoaderManager().initLoader(LOADER_ID_ENABLED_PRINT_SERVICES, null, this); |
| |
| // On first creation: |
| // |
| // If no services are installed, instantly open add printer dialog. |
| // If some are disabled and some are enabled show a toast to notify the user |
| if (savedInstanceState == null || !savedInstanceState.getBoolean(KEY_NOT_FIRST_CREATE)) { |
| List<PrintServiceInfo> allServices = |
| ((PrintManager) getSystemService(Context.PRINT_SERVICE)) |
| .getPrintServices(PrintManager.ALL_SERVICES); |
| boolean hasEnabledServices = false; |
| boolean hasDisabledServices = false; |
| |
| if (allServices != null) { |
| final int numServices = allServices.size(); |
| for (int i = 0; i < numServices; i++) { |
| if (allServices.get(i).isEnabled()) { |
| hasEnabledServices = true; |
| } else { |
| hasDisabledServices = true; |
| } |
| } |
| } |
| |
| if (!hasEnabledServices) { |
| startAddPrinterActivity(); |
| } else if (hasDisabledServices) { |
| String disabledServicesSetting = Settings.Secure.getString(getContentResolver(), |
| Settings.Secure.DISABLED_PRINT_SERVICES); |
| if (!TextUtils.isEmpty(disabledServicesSetting)) { |
| Toast.makeText(this, getString(R.string.print_services_disabled_toast), |
| Toast.LENGTH_LONG).show(); |
| } |
| } |
| } |
| |
| if (savedInstanceState != null) { |
| mDidSearch = savedInstanceState.getBoolean(KEY_DID_SEARCH); |
| mPrinterForInfoIntent = savedInstanceState.getParcelable(KEY_PRINTER_FOR_INFO_INTENT); |
| } |
| } |
| |
| @Override |
| protected void onSaveInstanceState(Bundle outState) { |
| super.onSaveInstanceState(outState); |
| outState.putBoolean(KEY_NOT_FIRST_CREATE, true); |
| outState.putBoolean(KEY_DID_SEARCH, mDidSearch); |
| outState.putParcelable(KEY_PRINTER_FOR_INFO_INTENT, mPrinterForInfoIntent); |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| super.onCreateOptionsMenu(menu); |
| |
| getMenuInflater().inflate(R.menu.select_printer_activity, menu); |
| |
| MenuItem searchItem = menu.findItem(R.id.action_search); |
| SearchView searchView = (SearchView) searchItem.getActionView(); |
| searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() { |
| @Override |
| public boolean onQueryTextSubmit(String query) { |
| return true; |
| } |
| |
| @Override |
| public boolean onQueryTextChange(String searchString) { |
| ((DestinationAdapter) mListView.getAdapter()).getFilter().filter(searchString); |
| return true; |
| } |
| }); |
| searchView.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() { |
| @Override |
| public void onViewAttachedToWindow(View view) { |
| if (AccessibilityManager.getInstance(SelectPrinterActivity.this).isEnabled()) { |
| view.announceForAccessibility(getString( |
| R.string.print_search_box_shown_utterance)); |
| } |
| } |
| @Override |
| public void onViewDetachedFromWindow(View view) { |
| if (!isFinishing() && AccessibilityManager.getInstance( |
| SelectPrinterActivity.this).isEnabled()) { |
| view.announceForAccessibility(getString( |
| R.string.print_search_box_hidden_utterance)); |
| } |
| } |
| }); |
| |
| return true; |
| } |
| |
| @Override |
| public boolean onOptionsItemSelected(MenuItem item) { |
| if (item.getItemId() == android.R.id.home) { |
| finish(); |
| return true; |
| } else { |
| return super.onOptionsItemSelected(item); |
| } |
| } |
| |
| @Override |
| public void onCreateContextMenu(ContextMenu menu, View view, ContextMenuInfo menuInfo) { |
| if (view == mListView) { |
| final int position = ((AdapterContextMenuInfo) menuInfo).position; |
| PrinterInfo printer = (PrinterInfo) mListView.getAdapter().getItem(position); |
| |
| // Printer is null if this is a context menu for the "add printer" entry |
| if (printer == null) { |
| return; |
| } |
| |
| menu.setHeaderTitle(printer.getName()); |
| |
| // Add the select menu item if applicable. |
| if (printer.getStatus() != PrinterInfo.STATUS_UNAVAILABLE) { |
| MenuItem selectItem = menu.add(Menu.NONE, R.string.print_select_printer, |
| Menu.NONE, R.string.print_select_printer); |
| Intent intent = new Intent(); |
| intent.putExtra(EXTRA_PRINTER, printer); |
| selectItem.setIntent(intent); |
| } |
| |
| // Add the forget menu item if applicable. |
| if (mPrinterRegistry.isFavoritePrinter(printer.getId())) { |
| MenuItem forgetItem = menu.add(Menu.NONE, R.string.print_forget_printer, |
| Menu.NONE, R.string.print_forget_printer); |
| Intent intent = new Intent(); |
| intent.putExtra(EXTRA_PRINTER_ID, printer.getId()); |
| forgetItem.setIntent(intent); |
| } |
| } |
| } |
| |
| @Override |
| public boolean onContextItemSelected(MenuItem item) { |
| switch (item.getItemId()) { |
| case R.string.print_select_printer: { |
| PrinterInfo printer = item.getIntent().getParcelableExtra(EXTRA_PRINTER); |
| onPrinterSelected(printer); |
| } return true; |
| |
| case R.string.print_forget_printer: { |
| PrinterId printerId = item.getIntent().getParcelableExtra(EXTRA_PRINTER_ID); |
| mPrinterRegistry.forgetFavoritePrinter(printerId); |
| } return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Adjust the UI if the enabled print services changed. |
| */ |
| private synchronized void onPrintServicesUpdate() { |
| updateEmptyView((DestinationAdapter)mListView.getAdapter()); |
| invalidateOptionsMenu(); |
| } |
| |
| @Override |
| public void onStart() { |
| super.onStart(); |
| onPrintServicesUpdate(); |
| } |
| |
| @Override |
| public void onPause() { |
| if (mAnnounceFilterResult != null) { |
| mAnnounceFilterResult.remove(); |
| } |
| super.onPause(); |
| } |
| |
| @Override |
| public void onStop() { |
| super.onStop(); |
| } |
| |
| @Override |
| protected void onDestroy() { |
| if (isFinishing()) { |
| DestinationAdapter adapter = (DestinationAdapter) mListView.getAdapter(); |
| List<PrinterInfo> printers = adapter.getPrinters(); |
| int numPrinters = adapter.getPrinters().size(); |
| |
| MetricsLogger.action(this, MetricsEvent.PRINT_ALL_PRINTERS, numPrinters); |
| MetricsLogger.count(this, PRINTERS_LISTED_COUNT, numPrinters); |
| |
| int numInfoPrinters = 0; |
| int numIconPrinters = 0; |
| for (int i = 0; i < numPrinters; i++) { |
| PrinterInfo printer = printers.get(i); |
| |
| if (printer.getInfoIntent() != null) { |
| numInfoPrinters++; |
| } |
| |
| if (printer.getHasCustomPrinterIcon()) { |
| numIconPrinters++; |
| } |
| } |
| |
| MetricsLogger.count(this, PRINTERS_INFO_COUNT, numInfoPrinters); |
| MetricsLogger.count(this, PRINTERS_ICON_COUNT, numIconPrinters); |
| } |
| |
| super.onDestroy(); |
| } |
| |
| @Override |
| protected void onActivityResult(int requestCode, int resultCode, Intent data) { |
| switch (requestCode) { |
| case INFO_INTENT_REQUEST_CODE: |
| if (resultCode == RESULT_OK && |
| data != null && |
| data.getBooleanExtra(PrintService.EXTRA_SELECT_PRINTER, false) && |
| mPrinterForInfoIntent != null && |
| mPrinterForInfoIntent.getStatus() != PrinterInfo.STATUS_UNAVAILABLE) { |
| onPrinterSelected(mPrinterForInfoIntent); |
| } |
| mPrinterForInfoIntent = null; |
| break; |
| default: |
| // not reached |
| } |
| } |
| |
| private void onPrinterSelected(PrinterInfo printer) { |
| Intent intent = new Intent(); |
| intent.putExtra(INTENT_EXTRA_PRINTER, printer); |
| setResult(RESULT_OK, intent); |
| finish(); |
| } |
| |
| public void updateEmptyView(DestinationAdapter adapter) { |
| if (mListView.getEmptyView() == null) { |
| View emptyView = findViewById(R.id.empty_print_state); |
| mListView.setEmptyView(emptyView); |
| } |
| TextView titleView = findViewById(R.id.title); |
| View progressBar = findViewById(R.id.progress_bar); |
| if (mEnabledPrintServices.size() == 0) { |
| titleView.setText(R.string.print_no_print_services); |
| progressBar.setVisibility(View.GONE); |
| } else if (adapter.getUnfilteredCount() <= 0) { |
| titleView.setText(R.string.print_searching_for_printers); |
| progressBar.setVisibility(View.VISIBLE); |
| } else { |
| titleView.setText(R.string.print_no_printers); |
| progressBar.setVisibility(View.GONE); |
| } |
| } |
| |
| private void announceSearchResultIfNeeded() { |
| if (AccessibilityManager.getInstance(this).isEnabled()) { |
| if (mAnnounceFilterResult == null) { |
| mAnnounceFilterResult = new AnnounceFilterResult(); |
| } |
| mAnnounceFilterResult.post(); |
| } |
| } |
| |
| @Override |
| public Loader<List<PrintServiceInfo>> onCreateLoader(int id, Bundle args) { |
| return new PrintServicesLoader((PrintManager) getSystemService(Context.PRINT_SERVICE), this, |
| PrintManager.ENABLED_SERVICES); |
| } |
| |
| @Override |
| public void onLoadFinished(Loader<List<PrintServiceInfo>> loader, |
| List<PrintServiceInfo> services) { |
| mEnabledPrintServices.clear(); |
| |
| if (services != null && !services.isEmpty()) { |
| final int numServices = services.size(); |
| for (int i = 0; i < numServices; i++) { |
| PrintServiceInfo service = services.get(i); |
| |
| mEnabledPrintServices.put(service.getComponentName(), service); |
| } |
| } |
| |
| onPrintServicesUpdate(); |
| } |
| |
| @Override |
| public void onLoaderReset(Loader<List<PrintServiceInfo>> loader) { |
| if (!isFinishing()) { |
| onLoadFinished(loader, null); |
| } |
| } |
| |
| /** |
| * Return the target SDK of the package that defined the printer. |
| * |
| * @param printer The printer |
| * |
| * @return The target SDK that defined a printer. |
| */ |
| private int getTargetSDKOfPrintersService(@NonNull PrinterInfo printer) { |
| ApplicationInfo serviceAppInfo; |
| try { |
| serviceAppInfo = getPackageManager().getApplicationInfo( |
| printer.getId().getServiceName().getPackageName(), 0); |
| } catch (PackageManager.NameNotFoundException e) { |
| Log.e(LOG_TAG, "Could not find package that defined the printer", e); |
| return Build.VERSION_CODES.KITKAT; |
| } |
| |
| return serviceAppInfo.targetSdkVersion; |
| } |
| |
| private final class DestinationAdapter extends BaseAdapter implements Filterable { |
| |
| private final Object mLock = new Object(); |
| |
| private final List<PrinterInfo> mPrinters = new ArrayList<>(); |
| |
| private final List<PrinterInfo> mFilteredPrinters = new ArrayList<>(); |
| |
| private CharSequence mLastSearchString; |
| |
| /** |
| * Get the currently known printers. |
| * |
| * @return The currently known printers |
| */ |
| @NonNull List<PrinterInfo> getPrinters() { |
| return mPrinters; |
| } |
| |
| public DestinationAdapter() { |
| mPrinterRegistry.setOnPrintersChangeListener(new PrinterRegistry.OnPrintersChangeListener() { |
| @Override |
| public void onPrintersChanged(List<PrinterInfo> printers) { |
| synchronized (mLock) { |
| mPrinters.clear(); |
| mPrinters.addAll(printers); |
| mFilteredPrinters.clear(); |
| mFilteredPrinters.addAll(printers); |
| if (!TextUtils.isEmpty(mLastSearchString)) { |
| getFilter().filter(mLastSearchString); |
| } |
| } |
| notifyDataSetChanged(); |
| } |
| |
| @Override |
| public void onPrintersInvalid() { |
| synchronized (mLock) { |
| mPrinters.clear(); |
| mFilteredPrinters.clear(); |
| } |
| notifyDataSetInvalidated(); |
| } |
| }); |
| } |
| |
| @Override |
| public Filter getFilter() { |
| return new Filter() { |
| @Override |
| protected FilterResults performFiltering(CharSequence constraint) { |
| synchronized (mLock) { |
| if (TextUtils.isEmpty(constraint)) { |
| return null; |
| } |
| FilterResults results = new FilterResults(); |
| List<PrinterInfo> filteredPrinters = new ArrayList<>(); |
| String constraintLowerCase = constraint.toString().toLowerCase(); |
| final int printerCount = mPrinters.size(); |
| for (int i = 0; i < printerCount; i++) { |
| PrinterInfo printer = mPrinters.get(i); |
| String description = printer.getDescription(); |
| if (printer.getName().toLowerCase().contains(constraintLowerCase) |
| || description != null && description.toLowerCase() |
| .contains(constraintLowerCase)) { |
| filteredPrinters.add(printer); |
| } |
| } |
| results.values = filteredPrinters; |
| results.count = filteredPrinters.size(); |
| return results; |
| } |
| } |
| |
| @Override |
| @SuppressWarnings("unchecked") |
| protected void publishResults(CharSequence constraint, FilterResults results) { |
| final boolean resultCountChanged; |
| synchronized (mLock) { |
| final int oldPrinterCount = mFilteredPrinters.size(); |
| mLastSearchString = constraint; |
| mFilteredPrinters.clear(); |
| if (results == null) { |
| mFilteredPrinters.addAll(mPrinters); |
| } else { |
| List<PrinterInfo> printers = (List<PrinterInfo>) results.values; |
| mFilteredPrinters.addAll(printers); |
| } |
| resultCountChanged = (oldPrinterCount != mFilteredPrinters.size()); |
| } |
| if (resultCountChanged) { |
| announceSearchResultIfNeeded(); |
| } |
| |
| if (!mDidSearch) { |
| MetricsLogger.action(SelectPrinterActivity.this, |
| MetricsEvent.ACTION_PRINTER_SEARCH); |
| mDidSearch = true; |
| } |
| notifyDataSetChanged(); |
| } |
| }; |
| } |
| |
| public int getUnfilteredCount() { |
| synchronized (mLock) { |
| return mPrinters.size(); |
| } |
| } |
| |
| @Override |
| public int getCount() { |
| synchronized (mLock) { |
| if (mFilteredPrinters.isEmpty()) { |
| return 0; |
| } else { |
| // Add "add printer" item to the end of the list. If the list is empty there is |
| // a link on the empty view |
| return mFilteredPrinters.size() + 1; |
| } |
| } |
| } |
| |
| @Override |
| public int getViewTypeCount() { |
| return 2; |
| } |
| |
| @Override |
| public int getItemViewType(int position) { |
| // Use separate view types for the "add printer" item an the items referring to printers |
| if (getItem(position) == null) { |
| return 0; |
| } else { |
| return 1; |
| } |
| } |
| |
| @Override |
| public Object getItem(int position) { |
| synchronized (mLock) { |
| if (position < mFilteredPrinters.size()) { |
| return mFilteredPrinters.get(position); |
| } else { |
| // Return null to mark this as the "add printer item" |
| return null; |
| } |
| } |
| } |
| |
| @Override |
| public long getItemId(int position) { |
| return position; |
| } |
| |
| @Override |
| public View getDropDownView(int position, View convertView, ViewGroup parent) { |
| return getView(position, convertView, parent); |
| } |
| |
| @Override |
| public View getView(int position, View convertView, ViewGroup parent) { |
| final PrinterInfo printer = (PrinterInfo) getItem(position); |
| |
| // Handle "add printer item" |
| if (printer == null) { |
| if (convertView == null) { |
| convertView = getLayoutInflater().inflate(R.layout.add_printer_list_item, |
| parent, false); |
| } |
| |
| return convertView; |
| } |
| |
| if (convertView == null) { |
| convertView = getLayoutInflater().inflate( |
| R.layout.printer_list_item, parent, false); |
| } |
| |
| convertView.setEnabled(isActionable(position)); |
| |
| |
| CharSequence title = printer.getName(); |
| Drawable icon = printer.loadIcon(SelectPrinterActivity.this); |
| |
| PrintServiceInfo service = mEnabledPrintServices.get(printer.getId().getServiceName()); |
| |
| CharSequence printServiceLabel = null; |
| if (service != null) { |
| printServiceLabel = service.getResolveInfo().loadLabel(getPackageManager()) |
| .toString(); |
| } |
| |
| CharSequence description = printer.getDescription(); |
| |
| CharSequence subtitle; |
| if (TextUtils.isEmpty(printServiceLabel)) { |
| subtitle = description; |
| } else if (TextUtils.isEmpty(description)) { |
| subtitle = printServiceLabel; |
| } else { |
| subtitle = getString(R.string.printer_extended_description_template, |
| printServiceLabel, description); |
| } |
| |
| TextView titleView = (TextView) convertView.findViewById(R.id.title); |
| titleView.setText(title); |
| |
| TextView subtitleView = (TextView) convertView.findViewById(R.id.subtitle); |
| if (!TextUtils.isEmpty(subtitle)) { |
| subtitleView.setText(subtitle); |
| subtitleView.setVisibility(View.VISIBLE); |
| } else { |
| subtitleView.setText(null); |
| subtitleView.setVisibility(View.GONE); |
| } |
| |
| LinearLayout moreInfoView = (LinearLayout) convertView.findViewById(R.id.more_info); |
| if (printer.getInfoIntent() != null) { |
| moreInfoView.setVisibility(View.VISIBLE); |
| moreInfoView.setOnClickListener(v -> { |
| Intent fillInIntent = new Intent(); |
| fillInIntent.putExtra(PrintService.EXTRA_CAN_SELECT_PRINTER, true); |
| |
| try { |
| mPrinterForInfoIntent = printer; |
| startIntentSenderForResult(printer.getInfoIntent().getIntentSender(), |
| INFO_INTENT_REQUEST_CODE, fillInIntent, 0, 0, 0); |
| } catch (SendIntentException e) { |
| mPrinterForInfoIntent = null; |
| Log.e(LOG_TAG, "Could not execute pending info intent: %s", e); |
| } |
| }); |
| } else { |
| moreInfoView.setVisibility(View.GONE); |
| } |
| |
| ImageView iconView = (ImageView) convertView.findViewById(R.id.icon); |
| if (icon != null) { |
| iconView.setVisibility(View.VISIBLE); |
| if (!isActionable(position)) { |
| icon.mutate(); |
| |
| TypedValue value = new TypedValue(); |
| getTheme().resolveAttribute(android.R.attr.disabledAlpha, value, true); |
| icon.setAlpha((int)(value.getFloat() * 255)); |
| } |
| iconView.setImageDrawable(icon); |
| } else { |
| iconView.setVisibility(View.GONE); |
| } |
| |
| return convertView; |
| } |
| |
| public boolean isActionable(int position) { |
| PrinterInfo printer = (PrinterInfo) getItem(position); |
| |
| if (printer == null) { |
| return true; |
| } else { |
| return printer.getStatus() != PrinterInfo.STATUS_UNAVAILABLE; |
| } |
| } |
| } |
| |
| private final class AnnounceFilterResult implements Runnable { |
| private static final int SEARCH_RESULT_ANNOUNCEMENT_DELAY = 1000; // 1 sec |
| |
| public void post() { |
| remove(); |
| mListView.postDelayed(this, SEARCH_RESULT_ANNOUNCEMENT_DELAY); |
| } |
| |
| public void remove() { |
| mListView.removeCallbacks(this); |
| } |
| |
| @Override |
| public void run() { |
| final int count = mListView.getAdapter().getCount(); |
| final String text; |
| if (count <= 0) { |
| text = getString(R.string.print_no_printers); |
| } else { |
| text = getResources().getQuantityString( |
| R.plurals.print_search_result_count_utterance, count, count); |
| } |
| mListView.announceForAccessibility(text); |
| } |
| } |
| } |
