Integrando la biblioteca ZXing directamente en mi aplicación de Android

Estoy escribiendo esto en una simple desesperación :) Me han asignado hacer un escáner de código de barras independiente (como prueba de concepto) para un teléfono Android 1.6.

Para esto he descubierto la biblioteca ZXing.

Busqué en Google, leí temas relacionados aquí en StackOverflow, usé un sentido común, etc. Nada parecía haber ayudado, y simplemente no puedo hacer un agujero en este bloqueo mental: /

Sé que es posible, usar la biblioteca y crear su propio escáner de código de barras independiente. He leído que usar el "Escáner de código de barras" proporcionado por la gente de Zxing es, con mucho, la solución más fácil (a través de Intent). Lamentablemente, esta no es una opción, y se desea una aplicación independiente.

Para resumir mi problema:

1. ¿Cómo integrar ZXing source lib en mi proyecto de Android Code a través de Eclipse?
2. Cuando está integrado ... ¿cómo hacer uso de la lib, para "cargar" la función de escaneo?
3. Casi se prefiere una guía paso a paso porque acabo de comenzar a trabajar en Eclipse.

He tratado de hacer que mi proyecto de código dependa de la carpeta de Android desde la carpeta de origen de ZXing. Cuando lo hago, surgen un puñado de errores, principalmente relacionados con 'org.apache' (??)

Simplemente no puedo entenderlo ... así que algunos consejos serían de gran ayuda.

De antemano, gracias :)

¡ACTUALIZAR! - GUÍA RESUELTA +

Me las he arreglado para resolverlo :) Y a continuación puedes leer la guía paso a paso para que pueda ayudar a otros con el mismo problema que tuve;)

1. Instale Apache Ant - ( Vea este video de YouTube para obtener ayuda de configuración )
2. Descargue la fuente de ZXing de la página de inicio de ZXing y extráigala
3. Con el uso de la línea de comandos de Windows (Ejecutar-> CMD) navegue al directorio raíz del archivo descargado zxing src .
4. En la ventana de la línea de comandos: escriba ant -f core/build.xmlpresione enter y deje que Apache funcione, es mágico [ tiene problemas? ]
5. Ingrese Eclipse -> nuevo proyecto de Android, basado en la carpeta de Android en el directorio que acaba de extraer
6. Haga clic con el botón derecho en la carpeta del proyecto -> Propiedades -> Ruta de compilación de Java -> Biblioteca -> Agregar archivos JAR externos ...
7. Navegue a la carpeta recién extraída y abra el directorio central y seleccione core.jar... ¡presione enter!

Ahora solo tiene que corregir algunos errores en las traducciones y el archivo AndroidManifest.xml :) Ahora puede compilar felizmente, y ahora tendrá una aplicación de escáner de código de barras independiente, basada en la fuente ZXing;)

Felices codificadores, espero que pueda ayudar a otros :)

Aquí hay una guía paso a paso sobre cómo generar y mostrar el código QR usando la biblioteca ZXing sin tener que instalar la aplicación de terceros. Nota: no tiene que compilar ZXing con ANT ni ninguna otra herramienta de compilación. El archivo core.jarestá disponible en el archivo zip publicado (lea a continuación).

1. Descargue la última versión de ZXing . - ( ZXing-*.zip)
2. Extraiga este archivo zip y búsquelo core.jaren el core/directorio.
3. Si está utilizando Eclipse IDE, arrastre y suelte core.jaren el libsdirectorio de su proyecto de Android. Cuando se le solicite, seleccione Copiar .
4. Copie las dos clases que figuran a continuación ( Contents.java& QRCodeEncoder.java) en el paquete principal de su proyecto de Android.
5. Crear un ImageView elemento en su Actividad para mostrar el código QR generado si aún no tiene uno. A continuación se da un ejemplo:
6. Use el fragmento de código a continuación para generar el código QR en formato de mapa de bits y mostrarlo en un ImageView.

Aquí hay un ImageViewelemento para agregar a su archivo XML de diseño de actividad:

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

Fragmento de código:

// 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();
}

Aquí está 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
    };
}

Y 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();
    }
}

los

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

desafortunadamente no funcionó para mí.

Esto es lo que funcionó para mí:

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

Encuentre el enlace aquí: https://github.com/journeyapps/zxing-android-embedded

¿Tienes problemas para construir con ANT? Sigue leyendo

Si ant -f core/build.xml dice algo como:

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

luego configure su JAVA_HOMEvariable de entorno en la carpeta java adecuada. Encontré tools.jar en mi (para Windows):

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

así que configuré mi JAVA_HOMEpara:

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

La razón de la sintaxis más corta que encontré en algún sitio que dice:

"Se recomienda encarecidamente que elija un directorio de instalación que no incluya espacios en el nombre de la ruta (por ejemplo, NO lo instale en C: \ Archivos de programa). Si Java está instalado en dicho directorio, es fundamental establecer JAVA_HOME variable de entorno a una ruta que no incluye espacios (por ejemplo, C: \ Progra ~ 1); si no lo hace, algunos programas generarán excepciones que dependen del valor de JAVA_HOME ".

Luego relancé cmd (importante porque el shell de DOS solo lee las variables de entorno al iniciarse, por lo que cambiar una variable de entorno requerirá que utilice un nuevo shell para obtener el valor actualizado)

y finalmente lo ant -f core/build.xmltrabajado.

Como algunas de las respuestas están desactualizadas, me gustaría proporcionar las mías propias.

Para integrar la biblioteca ZXing en su aplicación de Android como sugiere su Wiki , debe agregar 2 archivos Java a su proyecto:

• IntentIntegrator.java
• IntentResult.java

Luego, en Android Studio, agregue la siguiente línea al archivo build.gradle :

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

O si todavía usa Eclipse con el complemento ADT, agregue el archivo core.jar al subdirectorio libs de su proyecto (aquí Windows con pantalla completa y Mac con pantalla completa ):

Finalmente agregue este código a su 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();
}

La aplicación resultante le pedirá que instale e inicie la aplicación Barcode Scanner mediante ZXing (que volverá a su aplicación automáticamente después del escaneo):

Además, si desea crear y ejecutar la aplicación ZXing Test como inspiración para su propia aplicación:

Entonces necesitas 4 archivos Java de GitHub :

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

Y 3 archivos Jar del repositorio de Maven :

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

(Puede crear los archivos Jar usted mismo mvn package, si echa un vistazo a ZXing desde GitHub e instala ant y maven herramientas en su computadora).

Nota: si su proyecto no reconoce los archivos Jar, es posible que necesite actualizar la versión de Java en las Propiedades del proyecto:

Poner

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

en tus dependencias de Gradle. Tan fácil como eso. Antes de usar Android Studio y el sistema de compilación Gradle.

¿Has visto las páginas wiki en el sitio web de zxing? Parece que puede ser útil GettingStarted , DeveloperNotes y ScanningViaIntent .

Si solo necesita el core.jar de zxing, puede omitir ese proceso y obtener los JAR preconstruidos de la página wiki GettingStarted

El último ZXing (2.2) no tiene core.jar en la carpeta principal, pero puede obtener el core.jar desde el repositorio de zxing Maven aquí

Paso a paso para configurar zxing 3.2.1 en eclipse

1. Descargue zxing-master.zip desde " https://github.com/zxing/zxing "
2. Descomprima zxing-master.zip, use eclipse para importar el proyecto "android" en zxing-master
3. Descargue core-3.2.1.jar desde " http://repo1.maven.org/maven2/com/google/zxing/core/3.2.1/ "
4. Cree la carpeta "libs" en el proyecto "android" y pegue cor-3.2.1.jar en la carpeta libs
5. Haga clic en el proyecto: elija "propiedades" -> "Compilador Java" para cambiar el nivel a 1.7. Luego haga clic en "Android" y cambie "Objetivo de compilación del proyecto" a Android 4.4.2+, porque usar 1.7 requiere compilar con Android 4.4
6. Si "CameraConfigurationUtils.java" no existe en "zxing-master / android / app / src / main / java / com / google / zxing / client / android / camera /". Puede copiarlo desde "zxing-master / android-core / src / main / java / com / google / zxing / client / android / camera /" y pegarlo en su proyecto.
7. Proyecto de limpieza y construcción. Si su proyecto muestra un error sobre "switch - case", debe cambiarlos a "if - else".
8. Terminado. Proyecto de limpieza y construcción.
9. Enlace de referencia: Uso de ZXing para crear una aplicación de escaneo de código de barras de Android

Intenté todas las formas posibles para lograr esto y luego descubrí la versión Minified de xZing de JourneyApps. Lo porté para eclipse y lo compartí en GitHub.

Si está utilizando eclipse, use este proyecto: -

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

Si está utilizando Studio, use este proyecto: -

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

Ventajas

1. El escáner de código de barras incorporado en su aplicación no requiere la instalación de aplicaciones de terceros mediante la tienda de juegos.

2. No necesita confundirse entre los tarros Core, cliente de Android, etc. simplemente deje caer estos paquetes y los diseños relevantes en su proyecto y estará listo. Solo se requiere Jar es com.google.zxing: core: 3.2.0 que puede descargar desde

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

3. No es necesario agregar toneladas de paquetes. Vea las imágenes a continuación para comparar

Antes de :-

Después :-

4. La parte más importante es que son altamente personalizables, es decir. puede agregar luz de flash, usarla en fragmentos y apoyar el cambio de orientación.

5. Puede utilizar esta actividad de captura en la aplicación Cordova para escanear códigos de barras.

su actividad de captura en el manifiesto de la aplicación se vería así

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

y el complemento se verá así

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");
            }
        }
    }
}

Feliz integración !!

Los chicos de zxing han hecho que sea más fácil crear un proyecto de Android con 1.7. No es tan doloroso como solía ser. Este es un blog rápido para cualquier persona que desee crear un proyecto zxing para Android rápidamente.

• Verifique las fuentes de zxing de zxing.org
• Crea un proyecto de Android en tu eclipse
• Eliminar main.xml
• Haga clic derecho en el directorio "src" y presione importar. Navegue a los siguientes directorios en el orden mencionado. A medida que los agrega para importar uno por uno, asegúrese de tener el directorio src en el campo de edición del asistente de importación. Y que seleccione solo el directorio "com" en el árbol de directorios izquierdo. No seleccione src.
• núcleo
• integración de Android
• androide
• Asegúrese de que su versión de Android SDK sea 9, cualquier cosa menor y androidmanifest.xml llorará.
• Strings.xml en uno de los idiomas se cuna, solo ponga un / antes del carácter '

Un proyecto de Android para zxing 1.7 (pago del 20 de junio).

http://www.4shared.com/file/bFx8Y5Ys/zXingJune2010.html ( NO DISPONIBLE MÁS )

¿Por qué usar una biblioteca externa cuando los servicios de Google Play (desde la versión 7.8.0 ) incluyen un decodificador de código de barras?

Acabo de escribir un método, que decodifica los códigos de barras generados, Bitmappara String.

Hace exactamente lo que se solicita, solo sin el CaptureActivity...

Por lo tanto, se puede omitir la android-integrationbiblioteca en 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')
}

El método es el siguiente (que en realidad descodifica los códigos de barras generados, dentro de una prueba 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;
}

Esta biblioteca funciona de maravilla, fácil de integrar y usar. https://github.com/dm77/barcodescanner

Recientemente he usado Google Mobile Vision tanto en iOS como en Android. Recomiendo utilizar Google Barcode Scan. Es bastante sensible con cualquier orientación y el tiempo de procesamiento es bastante rápido. Se llama Google Mobile Vision.

La API Barcode Scanner detecta códigos de barras en tiempo real en cualquier orientación. También puede detectar y analizar varios códigos de barras en diferentes formatos al mismo tiempo.

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

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

Enfoque mucho más fácil.

Solo incluya la dependencia en el archivo gradle de su nivel de aplicación

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

Defina un botón en su archivo xml y escriba el código siguiente en el archivo Java en OnCreate () y dentro del botón de escucha OnClick

new IntentIntegrator(this).initiateScan();

Y escriba el siguiente código después de OnCreate () del archivo 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();

        }
    }

}

ACTUALIZACIÓN 2020: simplemente agregue esto a su archivo Gradle. Funciona perfectamente!

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