Impression Bluetooth et WIFI pour Android

nous aurions besoin d'une imprimante portable (portable, il est important) qui peut se connecter à téléphone android via bluetooth ou wifi.

Ce que je sais actuellement:

  • aucun SDK d'impression standard disponible pour Android cette fois
  • il y a un SDK non officiel appelé iPrint SDK . N'avez-vous essayé via le wifi ou bluetooth? Cela fonctionne?
  • Printershare affirme également être programmaticly disponible . Ce serait ok pour moi de payer les frais d'une fois 5 $pour cela par téléphone. Il a beaucoup de formats pris en charge. Avez-vous essayé avec un appareil portable? Je leur ai posé des questions sur la liste des imprimantes bluetooth prises en charge (car il a un élément de menu "Rechercher imprimante BT"), mais ils n'ont pas répondu.

Ce que j'ai besoin de savoir au-dessus de la déjà demandé:

  • Comment ne vous imprimez à partir de votre application android?
  • quel type d'imprimante utilisez-vous?
  • est-il prévu dans le SDK Standard android d'inclure l'impression? Quelle est la feuille de route? Il est désormais disponible en Bêta ou quelque chose?
  • si nous d'une façon ou d'une autre (Je ne pense pas) construire sa propre solution pour l'impression via bluetooth, pouvez-vous recommander des normes et des protocoles pour vérifier et apprendre?
42
demandé sur Gábor Lipták 2011-01-11 12:43:42

7 réponses

à partir de Android 4.4 vous pouvez imprimer des documents depuis un appareil vers une imprimante via wifi.

Les applications Android

peuvent désormais imprimer n'importe quel type de contenu via Wi-Fi ou des services hébergés dans le cloud tels que Google Cloud Print. Dans les applications compatibles avec l'impression, les utilisateurs peuvent découvrir les imprimantes disponibles, changer la taille du papier, choisir des pages spécifiques à imprimer et imprimer presque n'importe quel type de document, d'image ou de 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 s'étend PrintDocumentAdapter .

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

19
répondu Gunnar Karlsson 2013-12-08 00:12:01

impression via Bluetooth sur Android n'est pas possible dès maintenant (à ma connaissance), Car Android ne supporte pas les "profils" Bluetooth, tels que BPP (Basic Printing Profile), HCRP (Hardcopy Replacement Profile), BIP (Basic Imaging Profile), etc. qui sont les profils communs utilisés avec L'impression Bluetooth. Réf. ce savoir sur l'Impression de BT profils.

actuellement, Android prend en charge OPP (Object Push Profile) qui est utilisé pour envoyer des fichiers au fil Bluetooth.

pour avoir des profils d'impression bluetooth mis en œuvre dans la pile Bluetooth pour Android, vous pouvez vous référer Sybase-iAnywhere-Blue-SDK-for-Android , qui fournit un SDK pour ajouter cette fonctionnalité à L'implémentation BT stack existante sur Android.

pour l'impression Wifi, il existe de nombreuses applications sur le marché qui vous permettent d'imprimer divers documents et images à partir de votre téléphone Android. Voir PrinterShare pour une telle application. Pour l'impression Wifi, vous pouvez utiliser n'importe quelle imprimante que vous pouvez connecter sur ethernet (LAN).

également vérifier les imprimantes qui sont "Google Cloud Print" activé, qui utilise le nuage pour imprimer à une imprimante connectée n'importe où dans le monde, qui prend en charge ce protocole. C'est tout à fait nouveau sur le marché, mais quelque chose qui va certainement gagner en popularité au cours des prochaines années. Vérifiez application Cloud print ici . et faq ici .

J'espère que cela vous aidera à enlever quelques questions de votre liste.

16
répondu Roy Samuel 2011-05-27 04:57:14

Désolé je n'ai pas connaissance de l'impression à l'aide de dispositifs bluetooth.. Mais, j'ai fait quelques recherches sur l'impression en utilisant le wifi et posté ce code dans GitHub, vous pouvez vous y référer si nécessaire.. Android-wifi-impression - GitHub

c'est le flux de ce prototype.

  1. vérifie la connectivité.
  2. si connecté en WiFi.. je stocke cette configuration WiFi.
  3. maintenant vérifier si j'ai déjà les informations de l'imprimante (configuration WiFi de l'imprimante WiFi) est disponible ou non. Si disponible, je vais scanner et obtenir la liste des ScanResults WiFi et se connecte à cette autre.. Il affichera la liste du WiFi et en cliquant dessus, l'utilisateur se connectera à l'imprimante et stockera la configuration WiFi pour de futures tâches d'impression.
  4. une fois le travail d'impression terminé, je me connecte à ma connexion Wi-Fi ou Mobile précédente.
  5. maintenant retour à la 2ème étape.
  6. si l'utilisateur est connecté en Données mobiles, Je ne fais qu'activer le WiFi et suivre la 3e étape.
  7. une fois le travail D'impression terminé, Je ne fais que désactiver le WiFi. pour que nous soyons connectés à nouveau à la connexion Mobile. (C'est android par défaut).

ci-Dessous classe va prendre soin de tous les travaux d'impression dans ce prototype.

PrintUtility.classe

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 j'ai créé ce.

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

si vous souhaitez télécharger un fichier et imprimer ce, appel downloadAndPrint (fileUrl, nom du fichier)

8
répondu SureshCS50 2015-07-06 08:30:15

la seule impression que j'ai pu intégrer est pour le Bixolon SPP-R200. Ils ont un SDK décent disponible et est assez facile à trouver. Je suis à la recherche de 8 1/2 x 11 capacités bluetooth mais un sdk pour quelque chose comme ça semble être une commande assez grande en ce moment

7
répondu TMLZ77 2011-02-03 18:06:25

Star Micronics dispose d'un SDK pour l'impression Android via 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-ci de sorte que vos options sont soit une API d'imprimante spécifique ou une application d'impression tierce partie.

d'après mon expérience, il est préférable d'utiliser une API et non une application externe. La plus grande raison est que vous obtenez le contrôle total sur le comportement de l'imprimante. C'est facile à mettre en œuvre si L'API est construite intelligemment. L'utilisation d'une application tierce est limitative parce que vous ne pouvez pas personnaliser vos sorties d'impression comme vous le souhaitez.

la star SDK à laquelle je vous ai lié possède une très belle application qui vous permet de tester et de personnaliser de nombreuses fonctions d'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 commode. En plus de tout ça, c'est bien documentée.

Si vous choisissez cette voie, vous pouvez envoyer du texte brut à l'imprimante avec les commandes. L'API traite la conversion des données en ce que l'imprimante peut comprendre.

3
répondu LtH 2012-05-25 08:03:07

Il ya un autre SDK d'impression pour Android appelé APF. Il est basé sur des tasses donc jusqu'à des milliers d'imprimantes prises en charge. Sur Internet: isb-vietnam.com

2
répondu sangtan 2012-01-09 08:26:11

Zebra Technologies fournit également un SDK pour Android . J'ai essayé à la fois leur SDK et Bixolon's (je l'ai obtenu en écrivant à techsupp@bixolon.de). Les deux fonctionnent bien, mais si vous préférez utiliser un page description language pour définir vos documents, vous êtes probablement mieux en utilisant une imprimante zèbre.

2
répondu JAGP 2012-06-25 22:37:48