Bluetooth e WIFI stampa per Android

Question

Si avrebbe bisogno di una stampante portatile (palmare, è importante) che possono connettersi al telefono Android tramite Bluetooth o WiFi.

Quello che so al momento:

• Nessun SDK standard di stampa disponibile per Android questa volta
• C'è uno SDK non ufficiale chiamato iPrint SDK . Qualcuno di voi ha provato tramite WiFi o Bluetooth? Funziona?
• PrinterShare sostiene anche di essere programmaticly disponibili . Sarebbe bene per me di pagare la tassa di una volta $ 5 per ogni telefono. Ha un sacco di formati supportati. Hai provato con qualsiasi dispositivo palmare? Ho chiesto loro circa l'elenco delle stampanti Bluetooth supportati (dal momento che ha una voce di menu "ricerca di stampante BT"), ma non hanno risposto.

Quello che ho bisogno di sapere al di sopra del già chiesto:

• Come si fa a stampare dalla tua app Android?
• Che tipo di stampante si usa?
• E 'previsto nel SDK di Android standard per includere la stampa? Qual è la tabella di marcia? E 'ora disponibile come beta o qualcosa del genere?
• Se in qualche modo (non penso così) costruire una soluzione personalizzata per la stampa via Bluetooth, si può consigliare standard e protocolli per controllare e imparare?

Answer 1

A partire dalla Android 4.4 è possibile stampare documenti da un dispositivo a una stampante hardware tramite wifi.

  

applicazioni Android possono ora stampare qualsiasi tipo di contenuto tramite Wi-Fi o servizi cloud-hosted come Google Cloud Print. In applicazioni di stampa abilitati, gli utenti possono scoprire le stampanti disponibili, formati carta cambiamento, scegliere pagine specifiche da stampare, stampare e quasi ogni tipo di documento, immagine o file.

Un breve esempio di come avviare il processo di stampa:

private void doPrint() {
    PrintManager printManager = (PrintManager) getActivity().getSystemService(Context.PRINT_SERVICE);
    printManager.print("My document", new CustomPrintDocumentAdapter(getActivity()), null);
}

dove CustomPrintDocumentAdapter estende PrintDocumentAdapter .

Maggiori informazioni sono disponibili sul Android Developers .

Answer 2

Stampa tramite Bluetooth su Android non è possibile fin d'ora (come per la mia conoscenza), come Android non supporta i 'profili' Bluetooth, come ad esempio BPP (stampa di base Profilo), HCRP (Profilo di sostituzione Hardcopy), BIP (Base Imaging Profile), ecc, che sono i profili comuni utilizzati con la stampa Bluetooth. Ref. questo essere informato in caso di stampa profili di BT.

Al momento, Android supporta OPP (Object Push Profile) che viene utilizzato per inviare file tramite Bluetooth.

Per avere la stampa Bluetooth profili implementate all'interno del Bluetooth Stack per Android, è possibile consultare Sybase iAnywhere--blu-SDK-per-Android , che fornisce uno SDK per aggiungere questa funzionalità a quella esistente implementazione dello stack BT su Android.

Per la stampa Wifi, ci sono molte applicazioni sul mercato che consente di stampare i vari documenti e immagini dal tuo cellulare Android. Vedere PrinterShare per una di queste app. Per la stampa Wifi, è possibile utilizzare qualsiasi stampante che si può collegare su Ethernet (LAN).

Verificate anche le stampanti che sono 'Google Cloud Print' abilitato, che utilizza il cloud per stampare su una stampante collegata in qualsiasi parte del mondo, che supporti questo protocollo. Questo è abbastanza nuovo nel mercato, ma qualcosa che sarà sicuramente guadagnare trazione nel corso dei prossimi anni. Scopri cloud app stampa qui . e faq qui .

Spero che questo aiuta a tenere fuori un paio di domande dalla vostra lista.

Answer 3

Mi dispiace non hanno le conoscenze sulla stampa utilizzando la tecnologia Bluetooth dispositivi .. Ma, ho fatto qualche ricerca sulla stampa con wifi e postato quel codice in GitHub, è possibile fare riferimento a che, se necessario .. Android-wifi-print - GitHub

Questo è il flusso di quel prototipo.

1. connettività controlli.
2. Se collegato in WiFi .. am memorizzazione che la configurazione Wi-Fi.
3. Ora controllare se ho già le informazioni della stampante (configurazione WiFi della stampante WiFi) è disponibile o meno. Se disponibile, io la scansione e ottenere l'elenco del WiFi ScanResults e si collega a quel altro .. Sarà che mostra la lista di WiFi e cliccando su quella, l'utente si collegherà a stampante e negozi che la configurazione Wi-Fi per i futuri lavori di stampa.
4. Una volta completato processo di stampa, ho la connessione al Wi-Fi precedente o una connessione dati mobile.
5. Ora tornando al 2 ° step.
6. Se l'utente collegato in dati mobili, sto solo consentendo WiFi e dopo 3 ° step.
7. Una volta completato lavoro di stampa, sto solo disabilitando WiFi. in modo che, saremo di nuovo in contatto con la connessione dati mobile. (Che è Android di default).

Di seguito classe si prenderà cura di tutti i lavori di stampa in quel prototipo.

PrintUtility.class

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 l'aiuto dei seguenti link che ho creato questo.

• link per l'apprendimento di lavoro di stampa
• link per l'apprendimento di configurazione Wi-Fi e switching

Se si desidera stampare il file basta chiamare Stampa (file)

Se volete scaricare un file e di stampa che, chiamata downloadAndPrint (fileURL, nome del file)

Answer 4

Il solo la stampa sono stato in grado di integrare sia per il Bixolon SPP-R200. Hanno uno SDK decente disponibile ed è abbastanza facile da trovare. Sto cercando per 8 1/2 x 11 funzionalità Bluetooth, ma uno SDK per una cosa del genere sembra essere un ordine abbastanza alto in questo momento

Answer 5

Star Micronics ha uno SDK per Android la stampa via Bluetooth (così come wifi / ethernet e USB). Potete scaricarlo qui: http://www.starmicronics.com/support/SDKDocumentation.aspx.

Come accennato in precedenza, non è possibile stampare in modo nativo, a questo punto nel tempo in modo che le opzioni sono o una stampante specifica API o di un 3rd party stampa app.

Nella mia esperienza, è meglio utilizzare un'API e non un programma esterno. La ragione principale è che si ottiene il controllo totale sul funzionamento della stampante. E 'facile da implementare se l'API è costruito in modo intelligente. L'utilizzo di un 3rd party app è limitante perché non è possibile personalizzare le stampe il modo in cui si desidera.

La Stella SDK che vi ha collegato a un'applicazione di esempio veramente bello che consente di provare e personalizzare molte funzioni della stampante per vederli in azione. Ogni funzione è documentato nel codice sorgente. I comandi ei loro parametri sono disponibili nella stessa applicazione come un breve riferimento su schermo che è conveniente anche. In cima a tutto questo, è ben documentato.

Se si sceglie in questo modo, è possibile inviare il testo normale alla stampante con i comandi. Le maniglie API conversione dei dati in quello che la stampante possa capire.

Answer 6

C'è un altro stampa SDK per Android chiamato APF. Si basa su CUPS in modo fino a migliaia di stampanti supportate. Sito web: isb-vietnam.com

Answer 7

Zebra Technologies fornisce anche un SDK per Android . Ho provato sia la loro SDK e Bixolon di (ottenuto scrivendo a techsupp@bixolon.de). Entrambi funzionano bene, ma se si preferisce usare un linguaggio di descrizione pagina per definire i documenti si sono probabilmente meglio off utilizzando una stampante Zebra.