Bluetooth et WIFI impression pour Android

Question

Nous aurions besoin d'une imprimante portable (portable, il est important) qui peut se connecter au téléphone Android via Bluetooth ou Wi-Fi.

Ce que je sais actuellement:

• Pas d'impression standard SDK disponible pour Android cette fois
• Il y a un SDK non officiel appelé iPrint SDK . Avez-vous essayé de tout cela par wifi ou bluetooth? Est-ce que ça marche?
• PrinterShare prétend également être programmaticly disponible. Il serait ok pour moi de payer les frais une fois 5 $ pour elle par téléphone. Il a beaucoup de formats pris en charge. Avez-vous essayé avec un appareil de poche? Je leur ai posé des questions sur la liste des imprimantes Bluetooth pris en charge (car il a une « imprimante recherche de BT » élément de menu), mais ils n'ont pas répondu.

Qu'est-ce que je dois savoir au-dessus du déjà demandé:

• Comment imprimer-vous de votre application Android?
• Quel type d'imprimante utilisez-vous?
• Est-il prévu dans le SDK Android standard pour inclure l'impression? Quelle est la feuille de route? Est-il disponible maintenant Beta ou quelque chose?
• Si nous en quelque sorte (je ne pense pas ainsi) construire solution propre pour l'impression via Bluetooth, vous pouvez recommander des normes et des protocoles pour vérifier et apprendre?

Answer 1

A partir de Android 4.4 vous pouvez imprimer des documents à partir d'un appareil à une imprimante de matériel via wifi.

  

applications Android peuvent maintenant imprimer tout type de contenu sur le réseau Wi-Fi ou des services cloud hébergés tels que Google Cloud Print. Dans les applications d'impression compatibles, les utilisateurs peuvent découvrir les imprimantes disponibles, les formats de papier de changement, choisissez des pages à imprimer et imprimer presque tout type de document, image ou un fichier.

Un bref exemple de la façon de démarrer le processus d'impression:

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

où CustomPrintDocumentAdapter étend PrintDocumentAdapter .

Plus d'informations sont disponibles sur développeurs Android .

Answer 2

L'impression via Bluetooth sur Android n'est pas possible maintenant (selon ma connaissance), comme Android ne supporte pas les 'profils' Bluetooth, tels que BPP (impression de base Profil), HCRP (Hardcopy Profil de remplacement), PIF (Basic profil d'imagerie), etc. qui sont les profils communs utilisés avec l'impression Bluetooth. Réf. ce savoir sur l'impression profils BT.

À l'heure actuelle, prend en charge les applications OPP (Object Push Profile) qui est utilisé pour envoyer des fichiers via Bluetooth.

Pour avoir l'impression Bluetooth profils mis en œuvre dans la pile Bluetooth pour Android, vous pouvez consulter Sybase iAnywhere-Bleu-SDK-pour-Android , qui fournit un SDK pour ajouter cette fonctionnalité à la mise en œuvre pile BT existant sur Android.

Pour l'impression Wifi, il y a de nombreuses applications sur le marché qui vous permet d'imprimer divers documents et images depuis votre téléphone Android. Voir PrinterShare pour une telle application. Pour l'impression Wifi, vous pouvez utiliser l'imprimante que vous pouvez connecter via Ethernet (LAN).

Consultez également les imprimantes qui sont « Google Cloud Print » est activé, qui utilise le nuage pour imprimer sur une imprimante connectée partout dans le monde, que supporte ce protocole. Ceci est tout à fait nouveau sur le marché, mais quelque chose qui va certainement gain de traction au cours des années à venir. Consultez app Cloud Print . et faq .

Espérons que cela aide à prendre quelques questions sur votre liste.

Answer 3

Désolé je n'ai pas connaissance impression à l'aide des appareils Bluetooth .. Mais, je l'ai fait des recherches sur l'impression en utilisant le wifi et que le code à posté GitHub, vous pouvez consulter si nécessaire .. Android wifi-print - GitHub

Ceci est le flux de ce prototype.

1. connectivité vérifie.
2. Si vous êtes connecté en WiFi .. am stocker cette configuration WiFi.
3. Maintenant vérifier si je l'ai déjà les informations de l'imprimante (configuration WiFi de l'imprimante WiFi) est disponible ou non. Si elle est disponible, je vais numériser et obtenir la liste des WiFi ScanResults et se connecte à ce autre .. Il va montrer la liste de connexion Wi-Fi et en cliquant sur ce, l'utilisateur se connecte à l'imprimante et stocke cette configuration WiFi pour les travaux d'impression futurs.
4. Une fois finalise la tâche d'impression, je me connecte à ma précédente connexion WiFi ou de données mobiles.
5. va maintenant retourner à l'étape 2.
6. Si l'utilisateur connecté dans les données mobiles, je suis juste permettant WiFi et après 3 étapes.
7. Une fois finalise des tâches d'impression, je suis juste désactiver WiFi. de sorte que, nous serons de retour connecté à une connexion de données mobile. (Ce défaut est android).

Ci-dessous classe prendra soin de tous les travaux d'impression dans ce prototype.

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) {

    }

}

Avec l'aide des liens suivants que j'ai créé cela.

• lien pour l'apprentissage travail d'impression
• Lien pour l'apprentissage Configuration WiFi et commutation

Si vous voulez imprimer votre fichier il suffit d'appeler impression (fichier)

Si vous voulez télécharger un fichier et imprimer que, appel downloadAndPrint (fileURL, filename)

Answer 4

L'impression que je suis en mesure d'intégrer est le Bixolon SPP-R200. Ils ont un SDK décent disponible et il est assez facile à trouver. Je cherche 8 1/2 x 11 capacités Bluetooth, mais un sdk pour quelque chose comme ça semble être un ordre assez grand moment

Answer 5

Star Micronics a un SDK pour l'impression par l'intermédiaire d'applications Bluetooth (ainsi que WiFi / Ethernet et USB). Vous pouvez le télécharger ici: http://www.starmicronics.com/support/SDKDocumentation.aspx.

Comme mentionné ci-dessus, vous ne pouvez pas imprimer nativement à ce moment que vos options sont soit une API d'imprimante spécifique ou une application 3ème partie de l'impression.

Dans mon expérience, il est préférable d'utiliser une API et non une application externe. La principale raison est que vous obtenez un contrôle total sur le comportement de l'imprimante. Il est facile à mettre en œuvre si l'API est construit intelligemment. En utilisant une application 3ème partie est limite parce que vous ne pouvez pas personnaliser vos impression outs la façon dont vous voulez.

L'étoile SDK je vous lié à a une exemple d'application très agréable qui vous permet de tester et de personnaliser un grand nombre de fonctions de l'imprimante pour les voir en action. Chaque fonction est documentée dans le code source. Les commandes et leurs paramètres sont également disponibles dans l'application elle-même comme une référence rapide sur l'écran qui est pratique. En plus de tout cela, il est bien documenté.

Si vous choisissez cette façon, vous pouvez envoyer le texte brut à l'imprimante ainsi que des commandes. Les poignées API de conversion des données dans ce que l'imprimante peut comprendre.

Answer 6

Il y a un autre SDK d'impression pour Android appelé CSA. Il est basé sur CUPS donc jusqu'à des milliers d'imprimantes pris en charge. Site Web: isb-vietnam.com

Answer 7

Zebra Technologies fournit également une SDK pour Android . Je l'ai essayé à la fois leur SDK et Bixolon de (il a obtenu en écrivant à techsupp@bixolon.de). Les deux fonctionnent très bien, mais si vous préférez utiliser un langage de description de page pour définir vos documents, vous êtes probablement mieux avec une imprimerie Zebra.