Intégrer la bibliothèque ZXing directement dans mon application Android

J'écris ceci en désespoir de cause :) J'ai été chargé de créer un lecteur de codes-barres autonome (comme preuve de concept) sur un téléphone Android 1.6.

Pour cela, j'ai découvert la bibliothèque ZXing.

J'ai googlé, lu des sujets connexes ici sur StackOverflow utilisé le sens commun et ainsi de suite. Rien ne semble avoir aidé, et je ne peux tout simplement pas percer ce blocus mental: /

Je sais qu'il est possible d'utiliser la librairie et de créer votre propre lecteur de codes-barres autonome. J'ai lu que l'utilisation du "Barcode Scanner" fourni par les gens de Zxing est de loin la solution la plus simple (via Intent). Malheureusement, ce n'est pas une option et une application autonome est souhaitée.

Donc pour résumer mon problème:

1. Comment intégrer la bibliothèque source ZXing dans mon projet de code Android via Eclipse?
2. Une fois intégrée ... comment utiliser la librairie, pour "charger" la fonction de scan?
3. Un guide étape par étape est presque préférable car je viens de commencer à travailler dans Eclipse.

J'ai essayé de rendre mon projet de code dépendant du dossier Android du dossier source ZXing. Quand je le fais, une poignée d'erreurs apparaissent, principalement concernant 'org.apache' (??)

Je ne peux tout simplement pas le comprendre ... donc quelques indices seraient des plus utiles.

D'avance, merci :)

METTRE À JOUR! - RÉSOLU + GUIDE

J'ai réussi à le comprendre :) Et ci-dessous, vous pouvez lire le guide étape par étape afin qu'il puisse aider les autres avec le même problème que moi;)

1. Installez Apache Ant - ( Voir cette vidéo YouTube pour obtenir de l'aide sur la configuration )
2. Téléchargez la source ZXing depuis la page d'accueil de ZXing et extrayez-la
3. Avec l'utilisation de la ligne de commande Windows (Exécuter-> CMD), accédez au répertoire racine du fichier téléchargé zxing src.
4. Dans la fenêtre de ligne de commande - Tapez, ant -f core/build.xmlappuyez sur Entrée et laissez Apache fonctionner, c'est magique [ avoir des problèmes? ]
5. Entrez Eclipse -> nouveau projet Android, basé sur le dossier Android dans le répertoire que vous venez d'extraire
6. Cliquez avec le bouton droit sur le dossier du projet -> Propriétés -> Chemin de construction Java -> Bibliothèque -> Ajouter des fichiers JAR externes ...
7. Accédez au dossier nouvellement extrait et ouvrez le répertoire principal et sélectionnez core.jar... appuyez sur Entrée!

Il ne vous reste plus qu'à corriger quelques erreurs dans les traductions et le fichier AndroidManifest.xml :) Vous pouvez maintenant compiler avec plaisir et vous aurez maintenant une application de numérisation de codes à barres autonome fonctionnelle, basée sur la source ZXing;)

Heureux les gars de codage - j'espère que cela pourra aider les autres :)

Voici un guide étape par étape sur la façon de générer et d'afficher un code QR à l'aide de la bibliothèque ZXing sans avoir à installer l'application tierce. Remarque: vous n'avez pas besoin de construire ZXing avec ANT ou tout autre outil de construction. Le fichier core.jarest disponible dans l'archive zip publiée (lisez ci-dessous).

1. Téléchargez la dernière version de ZXing . - ( ZXing-*.zip)
2. Extrayez cette archive zip et recherchez core.jarsous le core/répertoire.
3. Si vous utilisez Eclipse IDE, faites un glisser-déposer core.jardans le libsrépertoire de votre projet Android. Lorsque vous y êtes invité, sélectionnez Copier .
4. Copiez les deux classes ci-dessous ( Contents.java& QRCodeEncoder.java) dans le package principal de votre projet Android.
5. Créez un ImageViewélément dans votre activité pour afficher le code QR généré si vous n'en avez pas déjà. Un exemple est donné ci-dessous:
6. Utilisez l'extrait de code ci-dessous pour générer le code QR au format Bitmap et l'afficher dans un fichier ImageView.

Voici un ImageViewélément à ajouter à votre fichier XML de mise en page d'activité:

<ImageView 
    android:id="@+id/qrCode"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginTop="50dp"
    android:layout_centerHorizontal="true"/>

Extrait de code:

// ImageView to display the QR code in.  This should be defined in 
// your Activity's XML layout file
ImageView imageView = (ImageView) findViewById(R.id.qrCode);

String qrData = "Data I want to encode in QR code";
int qrCodeDimention = 500;

QRCodeEncoder qrCodeEncoder = new QRCodeEncoder(qrData, null,
        Contents.Type.TEXT, BarcodeFormat.QR_CODE.toString(), qrCodeDimention);

try {
    Bitmap bitmap = qrCodeEncoder.encodeAsBitmap();
    imageView.setImageBitmap(bitmap);
} catch (WriterException e) {
    e.printStackTrace();
}

Voici Contents.java

//
// * Copyright (C) 2008 ZXing authors
// * 
// * 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.
// 

import android.provider.ContactsContract;

public final class Contents {
    private Contents() {
    }

    public static final class Type {

     // Plain text. Use Intent.putExtra(DATA, string). This can be used for URLs too, but string
     // must include "http://" or "https://".
        public static final String TEXT = "TEXT_TYPE";

        // An email type. Use Intent.putExtra(DATA, string) where string is the email address.
        public static final String EMAIL = "EMAIL_TYPE";

        // Use Intent.putExtra(DATA, string) where string is the phone number to call.
        public static final String PHONE = "PHONE_TYPE";

        // An SMS type. Use Intent.putExtra(DATA, string) where string is the number to SMS.
        public static final String SMS = "SMS_TYPE";

        public static final String CONTACT = "CONTACT_TYPE";

        public static final String LOCATION = "LOCATION_TYPE";

        private Type() {
        }
    }

    public static final String URL_KEY = "URL_KEY";

    public static final String NOTE_KEY = "NOTE_KEY";

    // When using Type.CONTACT, these arrays provide the keys for adding or retrieving multiple phone numbers and addresses.
    public static final String[] PHONE_KEYS = {
            ContactsContract.Intents.Insert.PHONE, ContactsContract.Intents.Insert.SECONDARY_PHONE,
            ContactsContract.Intents.Insert.TERTIARY_PHONE
    };

    public static final String[] PHONE_TYPE_KEYS = {
            ContactsContract.Intents.Insert.PHONE_TYPE,
            ContactsContract.Intents.Insert.SECONDARY_PHONE_TYPE,
            ContactsContract.Intents.Insert.TERTIARY_PHONE_TYPE
    };

    public static final String[] EMAIL_KEYS = {
            ContactsContract.Intents.Insert.EMAIL, ContactsContract.Intents.Insert.SECONDARY_EMAIL,
            ContactsContract.Intents.Insert.TERTIARY_EMAIL
    };

    public static final String[] EMAIL_TYPE_KEYS = {
            ContactsContract.Intents.Insert.EMAIL_TYPE,
            ContactsContract.Intents.Insert.SECONDARY_EMAIL_TYPE,
            ContactsContract.Intents.Insert.TERTIARY_EMAIL_TYPE
    };
}

Et QRCodeEncoder.java

/*
 * Copyright (C) 2008 ZXing authors
 * 
 * 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.
 */

import android.provider.ContactsContract;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.telephony.PhoneNumberUtils;

import java.util.Collection;
import java.util.EnumMap;
import java.util.HashSet;
import java.util.Map;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.WriterException;
import com.google.zxing.common.BitMatrix;

public final class QRCodeEncoder {
    private static final int WHITE = 0xFFFFFFFF;
    private static final int BLACK = 0xFF000000;

    private int dimension = Integer.MIN_VALUE;
    private String contents = null;
    private String displayContents = null;
    private String title = null;
    private BarcodeFormat format = null;
    private boolean encoded = false;

    public QRCodeEncoder(String data, Bundle bundle, String type, String format, int dimension) {
        this.dimension = dimension;
        encoded = encodeContents(data, bundle, type, format);
    }

    public String getContents() {
        return contents;
    }

    public String getDisplayContents() {
        return displayContents;
    }

    public String getTitle() {
        return title;
    }

    private boolean encodeContents(String data, Bundle bundle, String type, String formatString) {
        // Default to QR_CODE if no format given.
        format = null;
        if (formatString != null) {
            try {
                format = BarcodeFormat.valueOf(formatString);
            } catch (IllegalArgumentException iae) {
                // Ignore it then
            }
        }
        if (format == null || format == BarcodeFormat.QR_CODE) {
            this.format = BarcodeFormat.QR_CODE;
            encodeQRCodeContents(data, bundle, type);
        } else if (data != null && data.length() > 0) {
            contents = data;
            displayContents = data;
            title = "Text";
        }
        return contents != null && contents.length() > 0;
    }

    private void encodeQRCodeContents(String data, Bundle bundle, String type) {
        if (type.equals(Contents.Type.TEXT)) {
            if (data != null && data.length() > 0) {
                contents = data;
                displayContents = data;
                title = "Text";
            }
        } else if (type.equals(Contents.Type.EMAIL)) {
            data = trim(data);
            if (data != null) {
                contents = "mailto:" + data;
                displayContents = data;
                title = "E-Mail";
            }
        } else if (type.equals(Contents.Type.PHONE)) {
            data = trim(data);
            if (data != null) {
                contents = "tel:" + data;
                displayContents = PhoneNumberUtils.formatNumber(data);
                title = "Phone";
            }
        } else if (type.equals(Contents.Type.SMS)) {
            data = trim(data);
            if (data != null) {
                contents = "sms:" + data;
                displayContents = PhoneNumberUtils.formatNumber(data);
                title = "SMS";
            }
        } else if (type.equals(Contents.Type.CONTACT)) {
            if (bundle != null) {
                StringBuilder newContents = new StringBuilder(100);
                StringBuilder newDisplayContents = new StringBuilder(100);

                newContents.append("MECARD:");

                String name = trim(bundle.getString(ContactsContract.Intents.Insert.NAME));
                if (name != null) {
                    newContents.append("N:").append(escapeMECARD(name)).append(';');
                    newDisplayContents.append(name);
                }

                String address = trim(bundle.getString(ContactsContract.Intents.Insert.POSTAL));
                if (address != null) {
                    newContents.append("ADR:").append(escapeMECARD(address)).append(';');
                    newDisplayContents.append('\n').append(address);
                }

                Collection<String> uniquePhones = new HashSet<String>(Contents.PHONE_KEYS.length);
                for (int x = 0; x < Contents.PHONE_KEYS.length; x++) {
                    String phone = trim(bundle.getString(Contents.PHONE_KEYS[x]));
                    if (phone != null) {
                        uniquePhones.add(phone);
                    }
                }
                for (String phone : uniquePhones) {
                    newContents.append("TEL:").append(escapeMECARD(phone)).append(';');
                    newDisplayContents.append('\n').append(PhoneNumberUtils.formatNumber(phone));
                }

                Collection<String> uniqueEmails = new HashSet<String>(Contents.EMAIL_KEYS.length);
                for (int x = 0; x < Contents.EMAIL_KEYS.length; x++) {
                    String email = trim(bundle.getString(Contents.EMAIL_KEYS[x]));
                    if (email != null) {
                        uniqueEmails.add(email);
                    }
                }
                for (String email : uniqueEmails) {
                    newContents.append("EMAIL:").append(escapeMECARD(email)).append(';');
                    newDisplayContents.append('\n').append(email);
                }

                String url = trim(bundle.getString(Contents.URL_KEY));
                if (url != null) {
                    // escapeMECARD(url) -> wrong escape e.g. http\://zxing.google.com
                    newContents.append("URL:").append(url).append(';');
                    newDisplayContents.append('\n').append(url);
                }

                String note = trim(bundle.getString(Contents.NOTE_KEY));
                if (note != null) {
                    newContents.append("NOTE:").append(escapeMECARD(note)).append(';');
                    newDisplayContents.append('\n').append(note);
                }

                // Make sure we've encoded at least one field.
                if (newDisplayContents.length() > 0) {
                    newContents.append(';');
                    contents = newContents.toString();
                    displayContents = newDisplayContents.toString();
                    title = "Contact";
                } else {
                    contents = null;
                    displayContents = null;
                }

            }
        } else if (type.equals(Contents.Type.LOCATION)) {
            if (bundle != null) {
                // These must use Bundle.getFloat(), not getDouble(), it's part of the API.
                float latitude = bundle.getFloat("LAT", Float.MAX_VALUE);
                float longitude = bundle.getFloat("LONG", Float.MAX_VALUE);
                if (latitude != Float.MAX_VALUE && longitude != Float.MAX_VALUE) {
                    contents = "geo:" + latitude + ',' + longitude;
                    displayContents = latitude + "," + longitude;
                    title = "Location";
                }
            }
        }
    }

    public Bitmap encodeAsBitmap() throws WriterException {
        if (!encoded) return null;

        Map<EncodeHintType, Object> hints = null;
        String encoding = guessAppropriateEncoding(contents);
        if (encoding != null) {
            hints = new EnumMap<EncodeHintType, Object>(EncodeHintType.class);
            hints.put(EncodeHintType.CHARACTER_SET, encoding);
        }
        MultiFormatWriter writer = new MultiFormatWriter();
        BitMatrix result = writer.encode(contents, format, dimension, dimension, hints);
        int width = result.getWidth();
        int height = result.getHeight();
        int[] pixels = new int[width * height];
        // All are 0, or black, by default
        for (int y = 0; y < height; y++) {
            int offset = y * width;
            for (int x = 0; x < width; x++) {
                pixels[offset + x] = result.get(x, y) ? BLACK : WHITE;
            }
        }

        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
        return bitmap;
    }

    private static String guessAppropriateEncoding(CharSequence contents) {
        // Very crude at the moment
        for (int i = 0; i < contents.length(); i++) {
            if (contents.charAt(i) > 0xFF) { return "UTF-8"; }
        }
        return null;
    }

    private static String trim(String s) {
        if (s == null) { return null; }
        String result = s.trim();
        return result.length() == 0 ? null : result;
    }

    private static String escapeMECARD(String input) {
        if (input == null || (input.indexOf(':') < 0 && input.indexOf(';') < 0)) { return input; }
        int length = input.length();
        StringBuilder result = new StringBuilder(length);
        for (int i = 0; i < length; i++) {
            char c = input.charAt(i);
            if (c == ':' || c == ';') {
                result.append('\\');
            }
            result.append(c);
        }
        return result.toString();
    }
}

le

compile 'com.google.zxing:core:2.3.0'

malheureusement n'a pas fonctionné pour moi.

C'est ce qui a fonctionné pour moi:

dependencies {
   compile 'com.journeyapps:zxing-android-embedded:3.0.1@aar'
   compile 'com.google.zxing:core:3.2.0'
}

Veuillez trouver le lien ici: https://github.com/journeyapps/zxing-android-embedded

Vous rencontrez des problèmes pour construire avec ANT? Continue de lire

Si ant -f core/build.xml dit quelque chose comme:

Unable to locate tools.jar. Expected to find it in
C:\Program Files\Java\jre6\lib\tools.jar

puis définissez votre JAVA_HOMEvariable d'environnement dans le dossier java approprié. J'ai trouvé tools.jar dans mon (pour Windows):

C:\Program Files\Java\jdk1.6.0_21\lib

donc j'ai mis mon JAVA_HOMEà:

C:\Progra~1\Java\jdk1.6.0_25

la raison de la syntaxe plus courte que j'ai trouvée sur un site qui dit:

"Il est fortement conseillé de choisir un répertoire d'installation qui n'inclut pas d'espaces dans le nom du chemin (par exemple, ne pas installer dans C: \ Program Files). Si Java est installé dans un tel répertoire, il est essentiel de définir JAVA_HOME variable d'environnement vers un chemin qui n'inclut pas d'espaces (par exemple, C: \ Progra ~ 1); si vous ne le faites pas, des exceptions seront levées par certains programmes qui dépendent de la valeur de JAVA_HOME. "

J'ai ensuite relancé cmd (important car le shell DOS ne lit que les variables d'environnement lors du lancement, donc changer une variable d'environnement vous obligera à utiliser un nouveau shell pour obtenir la valeur mise à jour)

et enfin le ant -f core/build.xmltravaillé.

Étant donné que certaines des réponses sont obsolètes, j'aimerais fournir les miennes -

Pour intégrer la bibliothèque ZXing dans votre application Android comme suggéré par leur Wiki , vous devez ajouter 2 fichiers Java à votre projet:

• IntentIntegrator.java
• IntentResult.java

Ensuite, dans Android Studio, ajoutez la ligne suivante au fichier build.gradle :

dependencies {
    ....
    compile 'com.google.zxing:core:3.2.1'
}

Ou si vous utilisez toujours Eclipse avec ADT-plugin, ajoutez le fichier core.jar au sous-répertoire libs de votre projet (ici Windows en plein écran et Mac en plein écran ):

Enfin, ajoutez ce code à votre MainActivity.java :

public void scanQRCode(View v) {
    IntentIntegrator integrator = new IntentIntegrator(MainActivity.this);
    integrator.initiateScan(IntentIntegrator.QR_CODE_TYPES);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent intent) {
    IntentResult result = 
        IntentIntegrator.parseActivityResult(requestCode, resultCode, intent);
    if (result != null) {
        String contents = result.getContents();
        if (contents != null) {
            showDialog(R.string.result_succeeded, result.toString());
        } else {
            showDialog(R.string.result_failed,
                getString(R.string.result_failed_why));
        }
    }
}

private void showDialog(int title, CharSequence message) {
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle(title);
    builder.setMessage(message);
    builder.setPositiveButton(R.string.ok_button, null);
    builder.show();
}

L'application résultante demandera d'installer et de démarrer l' application Barcode Scanner par ZXing (qui reviendra automatiquement à votre application après la numérisation):

De plus, si vous souhaitez créer et exécuter l' application ZXing Test comme source d'inspiration pour votre propre application:

Ensuite, vous avez besoin de 4 fichiers Java de GitHub :

• BenchmarkActivity.java
• BenchmarkAsyncTask.java
• BenchmarkItem.java
• ZXingTestActivity.java

Et 3 fichiers Jar du référentiel Maven :

• core.jar
• android-core.jar
• android-integration.jar

(Vous pouvez créer les fichiers Jar vous-même avec mvn package- si vous extrayez ZXing à partir de GitHub et installez les outils ant et maven sur votre ordinateur).

Remarque: si votre projet ne reconnaît pas les fichiers Jar, vous devrez peut-être mettre à jour la version Java dans les propriétés du projet:

Mettre

compile 'com.google.zxing:core:2.3.0' 

dans vos dépendances Gradle. Aussi simple que ça. Avant d'utiliser Android Studio et le système de construction Gradle.

Avez-vous vu les pages wiki sur le site Web de zxing? Il semble que GettingStarted , DeveloperNotes et ScanningViaIntent vous soient utiles.

Si vous avez juste besoin du core.jar de zxing, vous pouvez ignorer ce processus et obtenir les JAR prédéfinis à partir de la page wiki GettingStarted

Le dernier ZXing (2.2) n'a pas core.jar sous le dossier principal mais vous pouvez obtenir le core.jar à partir du référentiel zxing Maven ici

Étape par étape pour configurer zxing 3.2.1 dans Eclipse

1. Téléchargez zxing-master.zip depuis " https://github.com/zxing/zxing "
2. Décompressez zxing-master.zip, utilisez eclipse pour importer le projet "android" dans zxing-master
3. Téléchargez core-3.2.1.jar depuis " http://repo1.maven.org/maven2/com/google/zxing/core/3.2.1/ "
4. Créez le dossier "libs" dans le projet "android" et collez cor-3.2.1.jar dans le dossier libs
5. Cliquez sur projet: choisissez "propriétés" -> "Java Compiler" pour changer le niveau à 1.7. Cliquez ensuite sur "Android" et remplacez "Project build target" par Android 4.4.2+, car l'utilisation de 1.7 nécessite la compilation avec Android 4.4
6. Si "CameraConfigurationUtils.java" n'existe pas dans "zxing-master / android / app / src / main / java / com / google / zxing / client / android / camera /". Vous pouvez le copier depuis "zxing-master / android-core / src / main / java / com / google / zxing / client / android / camera /" et le coller dans votre projet.
7. Projet de nettoyage et de construction. Si votre projet affiche une erreur concernant "switch - case", vous devez les changer en "if - else".
8. Terminé. Projet de nettoyage et de construction.
9. Lien de référence: Utilisation de ZXing pour créer une application de lecture de codes-barres Android

J'ai essayé tous les moyens possibles pour y parvenir, puis j'ai découvert la version minifiée de xZing par JourneyApps. J'ai porté cela pour eclipse et partagé sur GitHub.

Si vous utilisez eclipse, utilisez ce projet: -

https://github.com/hiteshsahu/XZing-Barcode-Scanner-Minified-Eclipse

Si vous utilisez Studio, utilisez ce projet: -

https://github.com/journeyapps/zxing-android-embedded

Avantages

1. Le scanner de codes à barres intégré dans votre application n'est pas nécessaire pour installer des applications tierces à l'aide de Playstore.

2. Vous n'avez pas besoin de vous tromper entre les jars Core, Android client, etc., déposez simplement ces packages et les mises en page pertinentes dans votre projet et vous êtes prêt à partir. Seul Jar requis est com.google.zxing: core: 3.2.0 que vous pouvez télécharger à partir de

   http://mvnrepository.com/artifact/com.google.zxing/core/3.2.0

3. Pas besoin d'ajouter des tonnes de paquets voir les images ci-dessous pour comparaison

Avant :-

Après :-

4. La partie la plus importante est qu'ils sont hautement personnalisables c'est-à-dire. vous pouvez ajouter une lumière flash, l'utiliser en fragment et prendre en charge le changement d'orientation.

5. Vous pouvez utiliser cette activité de capture dans l' application Cordova pour scanner les codes-barres.

votre activité de capture dans le manifeste de l'application ressemblerait à ceci

  <activity
            android:name="com.journeyapps.barcodescanner.CaptureActivity"
            android:clearTaskOnLaunch="true"
            android:configChanges="orientation|keyboardHidden"
            android:exported="false"
            android:screenOrientation="fullSensor"
            android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
            android:windowSoftInputMode="stateAlwaysHidden" >
            <intent-filter>
                <action android:name="com.google.zxing.client.android.SCAN" />

                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </activity>

et le plugin ressemblera à ceci

public class BarcodeScanner extends CordovaPlugin {
    public static final int REQUEST_CODE = 0x0ba7c0de;

    private static final String SCAN = "scan";
    private static final String CANCELLED = "cancelled";
    private static final String FORMAT = "format";
    private static final String TEXT = "text";
    private static final String SCAN_INTENT = "com.google.zxing.client.android.SCAN";

    private static final String LOG_TAG = "BarcodeScanner";

    private CallbackContext callbackContext;

    /**
     * Constructor.
     */
    public BarcodeScanner() {


    }

    /**
     * Executes the request.
     *
     * This method is called from the WebView thread. To do a non-trivial amount of work, use:
     *     cordova.getThreadPool().execute(runnable);
     *
     * To run on the UI thread, use:
     *     cordova.getActivity().runOnUiThread(runnable);
     *
     * @param action          The action to execute.
     * @param args            The exec() arguments.
     * @param callbackContext The callback context used when calling back into JavaScript.
     * @return                Whether the action was valid.
     *
     * @sa https://github.com/apache/cordova-android/blob/master/framework/src/org/apache/cordova/CordovaPlugin.java
     */
    @Override
    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) {
        this.callbackContext = callbackContext;
        if (action.equals(SCAN)) {
            scan(args);
        } else {
            return false;
        }
        return true;
    }

    /**
     * Starts an intent to scan and decode a barcode.
     */
    public void scan(JSONArray args) {
        Intent intentScan = new Intent(SCAN_INTENT);
        intentScan.addCategory(Intent.CATEGORY_DEFAULT);

        // add config as intent extras
        if(args.length() > 0) {

            JSONObject obj;
            JSONArray names;
            String key;
            Object value;

            for(int i=0; i<args.length(); i++) {

                try {
                    obj = args.getJSONObject(i);
                } catch(JSONException e) {
                    Log.i("CordovaLog", e.getLocalizedMessage());
                    continue;
                }

                names = obj.names();
                for(int j=0; j<names.length(); j++) {
                    try {
                        key = names.getString(j);
                        value = obj.get(key);

                        if(value instanceof Integer) {
                            intentScan.putExtra(key, (Integer)value);
                        } else if(value instanceof String) {
                            intentScan.putExtra(key, (String)value);
                        }

                    } catch(JSONException e) {
                        Log.i("CordovaLog", e.getLocalizedMessage());
                        continue;
                    }
                }
            }

        }

        // avoid calling other phonegap apps
        intentScan.setPackage(this.cordova.getActivity().getApplicationContext().getPackageName());

        this.cordova.startActivityForResult((CordovaPlugin) this, intentScan, REQUEST_CODE);
    }

    /**
     * Called when the barcode scanner intent completes.
     *
     * @param requestCode The request code originally supplied to startActivityForResult(),
     *                       allowing you to identify who this result came from.
     * @param resultCode  The integer result code returned by the child activity through its setResult().
     * @param intent      An Intent, which can return result data to the caller (various data can be attached to Intent "extras").
     */
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent intent) {
        if (requestCode == REQUEST_CODE) {
            if (resultCode == Activity.RESULT_OK) {
                JSONObject obj = new JSONObject();
                try {
                    obj.put(TEXT, intent.getStringExtra("SCAN_RESULT"));
                    obj.put(FORMAT, intent.getStringExtra("SCAN_RESULT_FORMAT"));
                    obj.put(CANCELLED, false);
                } catch (JSONException e) {
                    Log.d(LOG_TAG, "JSONException "+e.getMessage());
                }
                this.callbackContext.success(obj);
            } else if (resultCode == Activity.RESULT_CANCELED) {
                this.callbackContext.success("");
            } else {
                this.callbackContext.error("Technical Problem");
            }
        }
    }
}

Bonne intégration !!

Les gars de zxing ont facilité la création d'un projet Android avec 1.7. Ce n'est pas aussi douloureux qu'avant. Ceci est un blog rapide pour tous ceux qui souhaitent créer rapidement un projet zxing pour Android.

• Consultez les sources zxing sur zxing.org
• Créez un projet Android sur votre éclipse
• Supprimer main.xml
• Faites un clic droit sur le répertoire «src» et appuyez sur Importer. Accédez aux répertoires suivants dans l'ordre indiqué. Lorsque vous les ajoutez pour les importer un par un, assurez-vous que vous disposez du répertoire src dans le champ d'édition de l'assistant d'importation. Et que vous sélectionnez uniquement le répertoire «com» ​​dans l'arborescence de gauche. Ne sélectionnez pas src.
• coeur
• intégration android
• Android
• Assurez-vous que votre version Android SDK est 9, tout ce qui est inférieur et androidmanifest.xml pleurera.
• Strings.xml dans l'une des langues va crib, il suffit de mettre un / avant le caractère '

Un projet Android pour zxing 1.7 (paiement du 20 juin).

http://www.4shared.com/file/bFx8Y5Ys/zXingJune2010.html ( PLUS DISPONIBLE )

Pourquoi utiliser une bibliothèque externe, alors que les services google play (depuis la version 7.8.0 ) incluent un décodeur de code-barres.

Je viens d'écrire une méthode, qui décode les codes-barres générés, BitmappourString .

Il fait exactement ce qui est demandé, juste sans le CaptureActivity ...

Par conséquent, on peut sauter la android-integrationbibliothèque dans le build.gradle:

dependencies {
    // https://mvnrepository.com/artifact/com.google.zxing
    compile('com.google.zxing:core:3.3.0')
    compile('com.google.zxing:android-core:3.3.0')
}

La méthode comme suit (qui décode réellement les codes-barres générés, dans un test jUnit):

import android.graphics.Bitmap;

import com.google.zxing.BinaryBitmap;
import com.google.zxing.LuminanceSource;
import com.google.zxing.MultiFormatReader;
import com.google.zxing.NotFoundException;
import com.google.zxing.RGBLuminanceSource;
import com.google.zxing.common.HybridBinarizer;
import com.google.zxing.Result;

protected String decode(Bitmap bitmap) {

    MultiFormatReader reader = new MultiFormatReader();
    String barcode = null;

    int[] intArray = new int[bitmap.getWidth() * bitmap.getHeight()];
    bitmap.getPixels(intArray, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
    LuminanceSource source = new RGBLuminanceSource(bitmap.getWidth(), bitmap.getHeight(), intArray);
    BinaryBitmap binary = new BinaryBitmap(new HybridBinarizer(source));

    try {

        Result result = reader.decode(binary);
        // BarcodeFormat format = result.getBarcodeFormat(); 
        // ResultPoint[] points = result.getResultPoints();
        // byte[] bytes = result.getRawBytes(); 
        barcode = result.getText();

    } catch (NotFoundException e) {
        e.printStackTrace();
    }
    return barcode;
}

Cette bibliothèque fonctionne comme un charme, facile à intégrer et à utiliser. https://github.com/dm77/barcodescanner

J'ai récemment utilisé Google Mobile Vision sous iOS et Android. Je recommande vivement d'utiliser Google Barcode Scan. Il est assez réactif avec n'importe quelle orientation et le temps de traitement est assez rapide. Il s'appelle Google Mobile Vision.

L'API Barcode Scanner détecte les codes-barres en temps réel dans n'importe quelle orientation. Vous pouvez également détecter et analyser plusieurs codes-barres dans différents formats en même temps.

https://developers.google.com/vision/

https://codelabs.developers.google.com/codelabs/bar-codes/#0

Approche beaucoup plus simple.

Incluez simplement la dépendance dans le fichier gradle de votre application

compile 'com.journeyapps:zxing-android-embedded:3.0.1@aar'
compile 'com.google.zxing:core:3.2.0'  

Définissez un bouton dans votre fichier xml et écrivez le code ci-dessous dans le fichier Java dans OnCreate () et dans l'écouteur OnClick du bouton

new IntentIntegrator(this).initiateScan();

Et écrivez ci-dessous le code après OnCreate () du fichier Java

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    IntentResult result = IntentIntegrator.parseActivityResult(requestCode, resultCode, data);
    if(result != null) {
        if(result.getContents() == null) {
            Log.d("MainActivity", "Cancelled scan");
            Toast.makeText(this, "Cancelled", Toast.LENGTH_LONG).show();
        } else {
            Log.d("MainActivity", "Scanned");
            String st_scanned_result = result.getContents();
            Toast.makeText(this, "Scanned: " + result.getContents(), Toast.LENGTH_LONG).show();

        }
    }

}

MISE À JOUR 2020: ajoutez simplement ceci à votre fichier Gradle. Cela fonctionne parfaitement!

repositories {
   jcenter()
}
implementation 'me.dm7.barcodescanner:zxing:1.9.13'