Impresión Bluetooth y WIFI para Android

La impresión a través de Bluetooth en Android no es posible a partir de ahora (según mi conocimiento), ya que Android no admite "Perfiles" Bluetooth, como BPP (Perfil de impresión Básico), HCRP (Perfil de Reemplazo de copia impresa), BIP (Perfil de Imagen Básico), etc. cuáles son los perfiles comunes utilizados con la impresión Bluetooth. Ref. esto para saber sobre la impresión de perfiles BT.

Actualmente, Android es compatible con OPP (Object Push Profile) que se utiliza para enviar archivos a través de Bluetooth.

Tener al imprimir perfiles bluetooth implementados dentro de la pila Bluetooth para Android, puede consultar Sybase-iAnywhere-Blue-SDK-for-Android , que proporciona un SDK para agregar esta funcionalidad a la implementación de la pila BT existente en Android.

Para la impresión Wifi, hay muchas aplicaciones en el mercado que le permite imprimir varios documentos e imágenes desde su teléfono Android. Ver PrinterShare para una de estas aplicaciones. Para la impresión Wifi, puede usar cualquier impresora que pueda conectar a través de ethernet (LAN).

También echa un vistazo a las impresoras que están habilitadas 'Google Cloud Print', que utiliza la nube para imprimir en una impresora conectada en cualquier parte del mundo, que admite este protocolo. Esto es bastante nuevo en el mercado, pero algo que definitivamente ganará tracción en los próximos años. Echa un vistazo Cloud print app aquí. y faq aquí .

Espero que esto ayude a eliminar algunas preguntas de su lista.

Lo siento, no tengo conocimientos sobre la impresión con dispositivos bluetooth.. Pero, investigué un poco sobre la impresión usando wifi y publiqué ese código en GitHub, puedes referirte a eso si es necesario.. Android-wifi-print-GitHub

Este es el flujo de ese prototipo.

1. comprueba la conectividad.
2. Si está conectado en WiFi.. estoy almacenando esa configuración WiFi.
3. Ahora comprobando si ya tengo la información de la impresora (configuración WiFi de la impresora WiFi) es disponible o no. Si está disponible, voy a escanear y obtener una lista de resultados de escaneo WiFi y se conecta a eso más.. Mostrará la lista de WiFi y al hacer clic en eso, el usuario se conectará a la impresora y almacenará esa configuración WiFi para futuros trabajos de impresión.
4. Después de que se complete el trabajo de impresión, me estoy conectando a mi conexión Wi-Fi o de datos móviles anterior.
5. Ahora volviendo al 2do paso.
6. Si el usuario se conecta en datos móviles, solo estoy habilitando WiFi y siguiendo el 3er paso.
7. Después del trabajo de impresión completa, solo estoy desactivando WiFi. así que, estaremos conectados de nuevo a la conexión de datos móviles. (Que es el defecto de Android).

La clase de abajo se encargará de todos los trabajos de impresión en ese prototipo.

PrintUtility.clase

public class PrintUtility implements Observer {

    private static final int TIME_OUT = 10000;
    private static final int CONNECTION_TIME_OUT = 5000;

    private Activity mActivity;
    private Fragment mFragment = null;

    private WifiConfiguration mPrinterConfiguration;
    private WifiConfiguration mOldWifiConfiguration;
    private WifiManager mWifiManager;
    private WifiScanner mWifiScanner;
    private List<ScanResult> mScanResults = new ArrayList<ScanResult>();

    private PrintManager mPrintManager;
    private List<PrintJob> mPrintJobs;
    private PrintJob mCurrentPrintJob;

    private File pdfFile;
    private String externalStorageDirectory;

    private Handler mPrintStartHandler = new Handler();
    private Handler mPrintCompleteHandler = new Handler();
    private Handler mWifiConnectHandler = new Handler();
    private String connectionInfo;

    private boolean isMobileDataConnection = false;

    private PrintCompleteService mPrintCompleteService;

    //    Observer pattern
    private Observable mObservable;


    public PrintUtility(Activity mActivity, WifiManager mWifiManager, WifiScanner mWifiScanner) {
        this.mActivity = mActivity;
        this.mWifiManager = mWifiManager;
        this.mWifiScanner = mWifiScanner;
        mPrintCompleteService = (PrintCompleteService) mActivity;
        mObservable = ObservableSingleton.getInstance();
        mObservable.attach(this);
    }

    public PrintUtility(Activity mActivity, Fragment mFragment, WifiManager mWifiManager, WifiScanner mWifiScanner) {
        this.mActivity = mActivity;
        this.mFragment = mFragment;
        this.mWifiManager = mWifiManager;
        this.mWifiScanner = mWifiScanner;
        mPrintCompleteService = (PrintCompleteService) mFragment;
        mObservable = ObservableSingleton.getInstance();
        mObservable.attach(this);
    }

    public void downloadAndPrint(String fileUrl, final String fileName) {

        new FileDownloader(mActivity, fileUrl, fileName) {
            @Override
            protected void onPostExecute(Boolean result) {

                if (!result) {
                    mObservable.notifyObserver(true);
                } else {

                    // print flow will come here.

                    try {
                        externalStorageDirectory = Environment.getExternalStorageDirectory().toString();
                        File folder = new File(externalStorageDirectory, Constants.CONTROLLER_PDF_FOLDER);
                        pdfFile = new File(folder, fileName);
                    } catch (Exception e) {
                        mObservable.notifyObserver(true);
                        e.printStackTrace();
                    }

                    print(pdfFile);

                }

            }
        }.execute("");
    }

    public void print(final File pdfFile) {

        this.pdfFile = pdfFile;

        // check connectivity info -> mobile or wifi.
        connectionInfo = Util.connectionInfo(mActivity);

        if (connectionInfo.equalsIgnoreCase(Constants.CONTROLLER_MOBILE)) {
            // follow mobile flow.
            isMobileDataConnection = true;

            if (mWifiManager.isWifiEnabled() == false) {
                mWifiManager.setWifiEnabled(true);
            }

            mWifiManager.startScan();
            setScanResults(mWifiScanner.getScanResults());

            printerConfiguration();

        } else if (connectionInfo.equalsIgnoreCase(Constants.CONTROLLER_WIFI)) {
            // follow wifi flow..

            // this will get current wifiInfo and store it in shared preference.
            Util.storeCurrentWiFiConfiguration(mActivity);

            printerConfiguration();

        } else {
            mObservable.notifyObserver(true);
        }

    }

    private void printerConfiguration() {

        // check printer detail is available or not.
        mPrinterConfiguration = Util.getWifiConfiguration(mActivity, Constants.CONTROLLER_PRINTER);

        if (mPrinterConfiguration == null) {
            // printer configuration is not available.
            // display list of wifi available in an activity

            showWifiListActivity(Constants.REQUEST_CODE_PRINTER);

        } else {
            // get list of wifi available. if printer configuration available then connect it.
            // else.. show list of available wifi nearby.

            boolean isPrinterAvailable = false;

            // scans nearby wifi..
            mWifiManager.startScan();
            setScanResults(mWifiScanner.getScanResults());


            // checks this wifi in scan result list..
            for (int i = 0; i < mScanResults.size(); i++) {
                if (mPrinterConfiguration.SSID.equals("\"" + mScanResults.get(i).SSID + "\"")) {
                    isPrinterAvailable = true;
                    break;
                }
            }

            if (isPrinterAvailable) {

                // connect to printer wifi and show print settings dialog and continue with print flow.
                connectToWifi(mPrinterConfiguration);

                // prints document.
                doPrint();

            } else {
                showWifiListActivity(Constants.REQUEST_CODE_PRINTER);
            }

        }
    }

    private void showWifiListActivity(int requestCode) {
        Intent iWifi = new Intent(mActivity, WifiListActivity.class);
        mActivity.startActivityForResult(iWifi, requestCode);
    }

    private void connectToWifi(WifiConfiguration mWifiConfiguration) {
        mWifiManager.enableNetwork(mWifiConfiguration.networkId, true);
    }

    public void doPrint() {

        try {
            // it is taking some time to connect to printer.. so i used handler.. and waiting for its status.
            mPrintStartHandler.postDelayed(new Runnable() {
                @Override
                public void run() {

                    mPrintStartHandler.postDelayed(this, TIME_OUT);

                    if (mPrinterConfiguration.status == WifiConfiguration.Status.CURRENT) {
                        if (mWifiManager.getConnectionInfo().getSupplicantState() == SupplicantState.COMPLETED) {

                            if (Util.computePDFPageCount(pdfFile) > 0) {
                                printDocument(pdfFile);
                            } else {

                                AlertDialog.Builder alert = new AlertDialog.Builder(mActivity);

                                alert.setMessage("Can't print, Page count is zero.");

                                alert.setNeutralButton("OK", new DialogInterface.OnClickListener() {
                                    @Override
                                    public void onClick(DialogInterface dialog, int i) {
                                        dialog.dismiss();
                                        switchConnection();
                                    }
                                });

                                alert.show();
                            }
                        }
                        mPrintStartHandler.removeCallbacksAndMessages(null);
                    } else {
                        Toast.makeText(mActivity, "Failed to connect to printer!.", Toast.LENGTH_LONG).show();
                        switchConnection();
                        mPrintStartHandler.removeCallbacksAndMessages(null);
                    }
                }
            }, TIME_OUT);
        } catch (Exception e) {
            e.printStackTrace();
            Toast.makeText(mActivity, "Failed to connect to printer!.", Toast.LENGTH_LONG).show();
            switchConnection();
        }
    }

    @TargetApi(Build.VERSION_CODES.KITKAT)
    public void printDocument(File pdfFile) {

        mPrintManager = (PrintManager) mActivity.getSystemService(Context.PRINT_SERVICE);

        String jobName = mActivity.getResources().getString(R.string.app_name) + " Document";

        mCurrentPrintJob = mPrintManager.print(jobName, new PrintServicesAdapter(mActivity, mFragment, pdfFile), null);
    }


    @TargetApi(Build.VERSION_CODES.KITKAT)
    public void completePrintJob() {
        mPrintJobs = mPrintManager.getPrintJobs();

        mPrintCompleteHandler.postDelayed(new Runnable() {
            @Override
            public void run() {

                mPrintCompleteHandler.postDelayed(this, CONNECTION_TIME_OUT);

                if (mCurrentPrintJob.getInfo().getState() == PrintJobInfo.STATE_COMPLETED) {

                    // remove that PrintJob from PrintManager.
                    for (int i = 0; i < mPrintJobs.size(); i++) {
                        if (mPrintJobs.get(i).getId() == mCurrentPrintJob.getId()) {
                            mPrintJobs.remove(i);
                        }
                    }

                    // switching back to previous connection..
                    switchConnection();

                    // stops handler..
                    mPrintCompleteHandler.removeCallbacksAndMessages(null);
                } else if (mCurrentPrintJob.getInfo().getState() == PrintJobInfo.STATE_FAILED) {
                    switchConnection();
                    Toast.makeText(mActivity, "Print Failed!", Toast.LENGTH_LONG).show();
                    mPrintCompleteHandler.removeCallbacksAndMessages(null);
                } else if (mCurrentPrintJob.getInfo().getState() == PrintJobInfo.STATE_CANCELED) {
                    switchConnection();
                    Toast.makeText(mActivity, "Print Cancelled!", Toast.LENGTH_LONG).show();
                    mPrintCompleteHandler.removeCallbacksAndMessages(null);
                }

            }
        }, CONNECTION_TIME_OUT);
    }

    public void switchConnection() {
        try {
            if (!isMobileDataConnection) {

                mOldWifiConfiguration = Util.getWifiConfiguration(mActivity, Constants.CONTROLLER_WIFI);

                // get list of wifi available. if wifi configuration available then connect it.
                // else.. show list of available wifi nearby.
                boolean isWifiAvailable = false;

                // scans nearby wifi.
                mWifiManager.startScan();
                setScanResults(mWifiScanner.getScanResults());

                // checks this wifi in scan result list.
                for (int i = 0; i < mScanResults.size(); i++) {
                    if (mOldWifiConfiguration.SSID.equals("\"" + mScanResults.get(i).SSID + "\"")) {
                        isWifiAvailable = true;
                        break;
                    }
                }

                if (isWifiAvailable) {

                    // connect to printer wifi and show print settings dialog and continue with print flow.
                    connectToWifi(mOldWifiConfiguration);

                    mWifiConnectHandler.postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            mWifiConnectHandler.postDelayed(this, TIME_OUT);
                            if (mOldWifiConfiguration.status == WifiConfiguration.Status.CURRENT) {
                                if (mWifiManager.getConnectionInfo().getSupplicantState() == SupplicantState.COMPLETED) {

                                    try {
                                        mObservable.notifyObserver(true);
                                    } catch (Exception e) {
                                        e.printStackTrace();
                                    }

                                    mWifiConnectHandler.removeCallbacksAndMessages(null);
                                }
                            }
                        }
                    }, TIME_OUT);

                } else {
                    showWifiListActivity(Constants.REQUEST_CODE_WIFI);
                }
            } else {
                mWifiManager.setWifiEnabled(false);
                mObservable.notifyObserver(true);
            }
        } catch (Exception e) {
            mObservable.notifyObserver(true);
            e.printStackTrace();
        }
    }

    public void getPrinterConfigAndPrint() {
        mPrinterConfiguration = Util.getWifiConfiguration(mActivity, Constants.CONTROLLER_PRINTER);
        doPrint();
    }

    public void setScanResults(List<ScanResult> scanResults) {
        this.mScanResults = scanResults;
    }

    public void onPrintCancelled() {
        switchConnection();
    }

    @Override
    public void update() {
        mObservable.detach(this);
    }

    @Override
    public void updateObserver(boolean bool) {

    }

    @Override
    public void updateObserverProgress(int percentage) {

    }

}

Con la ayuda de los siguientes enlaces he creado esto.

• Enlace para aprender Trabajo de impresión
• Enlace para aprender Configuración y conmutación WiFi

Si desea imprimir su archivo simplemente llame a print (file)

Si desea descargar un archivo e imprimirlo, call downloadAndPrint (fileURL, fileName)

La única impresión que he podido integrar es para el Bixolon SPP-R200. Tienen un SDK decente disponible y es bastante fácil de encontrar. Estoy buscando 8 1/2 x 11 capacidades bluetooth, pero un sdk para algo así parece ser una orden bastante alto en este momento

Star Micronics tiene un SDK para la impresión de Android a través de Bluetooth (así como wifi/ethernet y USB). Puedes descargarlo aquí: http://www.starmicronics.com/support/SDKDocumentation.aspx .

Como se mencionó anteriormente, no puede imprimir de forma nativa en este momento, por lo que sus opciones son una API de impresora específica o una aplicación de impresión de terceros.

En mi experiencia, lo mejor es usar una API y no una aplicación externa. La mayor razón es que obtienes el control total sobre comportamiento de la impresora. Es fácil de implementar si la API se construye de forma inteligente. El uso de una aplicación de terceros es limitante porque no puede personalizar sus impresiones de la manera que desee.

El SDK de Star al que te vinculé tiene una aplicación de ejemplo muy buena que te permite probar y personalizar muchas funciones de impresora para verlas en acción. Cada función está documentada en el código fuente. Los comandos y sus parámetros también están disponibles en la propia aplicación como una referencia rápida en pantalla que es conveniente. Además de todo eso, está bien documentado.

Si elige esta opción, puede enviar texto sin formato a la impresora junto con comandos. La API se encarga de convertir los datos en lo que la impresora puede entender.

Hay otro SDK de impresión para Android llamado APF. Se basa en CUPS por lo que hasta miles de impresoras compatibles. Sitio web: isb-vietnam.com

Zebra Technologies también proporciona un SDK para Android. He probado tanto su SDK y Bixolon (lo conseguí escribiendo a [email protected]). Ambos funcionan bien, pero si prefiere usar un lenguaje de descripción de página para definir sus documentos, probablemente sea mejor usar una impresora Zebra.