Integrando a biblioteca ZXing diretamente no meu aplicativo Android

Estou escrevendo isso por mero desespero :) Fui designado para fazer um scanner de código de barras independente (como prova de conceito) para um telefone Android 1.6.

Por isso, descobri a biblioteca ZXing.

Eu pesquisei no Google, li tópicos relacionados aqui no StackOverflow usando o senso comum e assim por diante. Nada parecia ter ajudado, e eu simplesmente não consigo fazer um buraco nesse bloqueio mental: /

Sei que é possível usar a lib e criar seu próprio scanner de código de barras independente. Eu li que usar o "Barcode Scanner" fornecido pelo pessoal do Zxing é de longe a solução mais fácil (via Intent). Infelizmente, isso não é uma opção, e um aplicativo independente é desejado.

Então, para resumir meu problema:

1. Como integrar a biblioteca de código-fonte do ZXing ao meu projeto de código do Android por meio do Eclipse?
2. Quando integrado ... como fazer uso da lib, para "carregar" a função de verificação?
3. Um guia passo a passo é quase preferido, porque eu comecei a trabalhar no Eclipse.

Tentei tornar meu projeto de código dependente da pasta Android da pasta de origem ZXing. Quando faço isso, surgem alguns erros, principalmente sobre 'org.apache' (??)

Eu simplesmente não consigo entender ... então algumas dicas seriam muito úteis.

De antemão, obrigado :)

ATUALIZAR! - RESOLVIDO + GUIA

Eu consegui descobrir isso :) E abaixo, você pode ler o guia passo a passo para que, com sorte, possa ajudar outras pessoas com o mesmo problema que eu;)

1. Instale o Apache Ant - ( veja este vídeo do YouTube para obter ajuda sobre configuração )
2. Baixe a fonte do ZXing na página inicial do ZXing e extraia-a
3. Com o uso da linha de comando do Windows (Executar-> CMD), navegue até o diretório raiz do baixado zxing src.
4. Na janela da linha de comando - Digite ant -f core/build.xmlpressione enter e deixe o Apache funcionar é mágico [está com problemas? ]
5. Digite Eclipse -> novo projeto Android, com base na pasta android no diretório que você acabou de extrair
6. Clique com o botão direito do mouse na pasta do projeto -> Propriedades -> Caminho de Construção Java -> Biblioteca -> Incluir JARs Externos ...
7. Navegue até a pasta recém-extraída, abra o diretório principal e selecione core.jar... pressione enter!

Agora você só precisa corrigir alguns erros nas traduções e no arquivo AndroidManifest.xml :) Agora você pode compilar com alegria e agora terá um aplicativo de scanner de código de barras independente, baseado na fonte ZXing;)

Feliz pessoal de codificação - espero que possa ajudar os outros :)

Aqui está um guia passo a passo sobre como gerar e exibir código QR usando a biblioteca ZXing sem precisar instalar o aplicativo de terceiros. Nota: você não precisa criar o ZXing com o ANT ou qualquer outra ferramenta de criação. O arquivo core.jarestá disponível no arquivo zip lançado (leia abaixo).

1. Faça o download da versão mais recente do ZXing . - ( ZXing-*.zip)
2. Extraia esse arquivo zip e encontre core.jarno core/diretório
3. Se você estiver usando o Eclipse IDE, arraste e solte core.jarno libsdiretório do seu projeto Android. Quando solicitado, selecione Copiar .
4. Copie as duas classes dadas abaixo ( Contents.java& QRCodeEncoder.java) para o pacote principal do seu projeto Android.
5. Crie um ImageViewitem em sua Atividade para exibir o código QR gerado, se você ainda não tiver um. Um exemplo é dado abaixo:
6. Use o snippet de código abaixo para gerar o código QR no formato Bitmap e exibi-lo em um ImageView.

Aqui está um ImageViewelemento para adicionar ao seu arquivo XML de layout de atividade:

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

Aqui 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
    };
}

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

o

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

infelizmente não funcionou para mim.

Isto é o que funcionou para mim:

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

Por favor, encontre o link aqui: https://github.com/journeyapps/zxing-android-embedded

Tendo problemas para criar com a ANT? Continue lendo

Se ant -f core/build.xml diz algo como:

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

em seguida, defina sua JAVA_HOMEvariável de ambiente para a pasta java apropriada. Encontrei tools.jar no meu (para Windows):

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

então eu configurei o meu JAVA_HOMEpara:

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

o motivo da sintaxe mais curta que encontrei em algum site que diz:

"É altamente recomendável que você escolha um diretório de instalação que não inclua espaços no nome do caminho (por exemplo, NÃO instale em C: \ Arquivos de Programas). Se o Java estiver instalado nesse diretório, é fundamental definir o JAVA_HOME variável de ambiente para um caminho que não inclui espaços (por exemplo, C: \ Progra ~ 1); a falha ao fazer isso resultará em exceções geradas por alguns programas que dependem do valor de JAVA_HOME. "

Em seguida, relancei o cmd (importante porque o shell do DOS só lê env vars após o lançamento, portanto, alterar um env var exigirá o uso de um novo shell para obter o valor atualizado)

e finalmente o ant -f core/build.xmlfuncionou.

Como algumas das respostas estão desatualizadas, eu gostaria de fornecer as minhas -

Para integrar a biblioteca ZXing ao seu aplicativo Android, conforme sugerido pelo Wiki , você precisa adicionar 2 arquivos Java ao seu projeto:

• IntentIntegrator.java
• IntentResult.java

Em seguida, no Android Studio, adicione a seguinte linha ao arquivo build.gradle :

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

Ou, se ainda estiver usando o Eclipse com o plug-in ADT, adicione o arquivo core.jar ao subdiretório libs do seu projeto (aqui Windows em tela cheia e Mac em tela cheia ):

Por fim, adicione este código ao seu 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();
}

O aplicativo resultante solicitará a instalação e o início do aplicativo Barcode Scanner pelo ZXing (que retornará ao seu aplicativo automaticamente após a digitalização):

Além disso, se você deseja criar e executar o aplicativo ZXing Test como inspiração para seu próprio aplicativo:

Então você precisa de 4 arquivos Java do GitHub :

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

E 3 arquivos Jar do repositório Maven :

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

(Você pode criar os arquivos Jar mvn package- se você verificar o ZXing no GitHub e instalar as ferramentas ant e maven no seu computador).

Nota: se o seu projeto não reconhecer os arquivos Jar, talvez seja necessário atualizar a versão Java nas Propriedades do projeto:

Colocar

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

em suas dependências Gradle. Tão fácil quanto isso. Antes de usar o sistema de compilação Android Studio e Gradle.

Você já viu as páginas wiki no site zxing? Parece que você pode achar GettingStarted , DeveloperNotes e ScanningViaIntent úteis.

Se você apenas precisar do core.jar do zxing, poderá pular esse processo e obter os JARs pré-criados na página da wiki GettingStarted

O ZXing mais recente (2.2) não possui core.jar na pasta core, mas você pode obter o core.jar no repositório zxing Maven aqui

Passo a passo para configurar o zxing 3.2.1 no eclipse

1. Faça o download do zxing-master.zip em " https://github.com/zxing/zxing "
2. Descompacte zxing-master.zip, use eclipse para importar o projeto "android" no zxing-master
3. Faça o download do core-3.2.1.jar em " http://repo1.maven.org/maven2/com/google/zxing/core/3.2.1/ "
4. Crie a pasta "libs" no projeto "android" e cole cor-3.2.1.jar na pasta libs
5. Clique no projeto: escolha "propriedades" -> "Java Compiler" para alterar o nível para 1,7. Em seguida, clique em "Android" e altere "Alvo de criação do projeto" para o Android 4.4.2+, porque o uso do 1.7 requer compilação com o Android 4.4
6. Se "CameraConfigurationUtils.java" não existir em "zxing-master / android / app / src / main / java / com / google / zxing / cliente / android / camera /". Você pode copiá-lo de "zxing-master / android-core / src / main / java / com / google / zxing / client / android / camera /" e colar no seu projeto.
7. Limpe e construa o projeto. Se o seu projeto mostrar erro sobre "switch - case", você deve alterá-lo para "if - else".
8. Concluído. Limpe e construa o projeto.
9. Link de referência: usando o ZXing para criar um aplicativo de leitura de código de barras Android

Tentei de todas as maneiras possíveis para conseguir isso e descobri a versão Minified do xZing da JourneyApps. Eu tenho portado isso para eclipse e compartilhado no GitHub.

Se você estiver usando o eclipse, use este projeto: -

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

Se você estiver usando o Studio, use este projeto: -

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

Vantagens

1. O scanner de código de barras embutido no seu aplicativo não é necessário para instalar aplicativos de terceiros usando o playstore.

2. Você não precisa se confundir entre os frascos do cliente Core, Android, etc. Somente o Jar necessário é com.google.zxing: core: 3.2.0, do qual você pode baixar

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

3. Não há necessidade de adicionar toneladas de pacotes, veja as imagens abaixo para comparação

Antes :-

Depois de :-

4. A parte mais importante é que eles são altamente personalizáveis, isto é. você pode adicionar a luz do flash, usá-la em fragmentos e apoiar a alteração da orientação.

5. Você pode usar esta atividade de captura no Cordova App para digitalizar códigos de barras.

sua atividade de captura no manifesto do aplicativo ficaria assim

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

e plugin será parecido com este

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

Integração feliz !!

O pessoal do zxing facilitou a criação de um projeto Android com 1.7. Não é tão doloroso como costumava ser. Este é um blog rápido para quem deseja criar rapidamente um projeto zxing para android.

• Faça o checkout das fontes do zxing em zxing.org
• Crie um projeto Android no seu eclipse
• Excluir main.xml
• Clique com o botão direito no diretório "src" e clique em Importar. Navegue para os seguintes diretórios na ordem mencionada. Ao adicioná-los para importação, um por um, verifique se você possui o diretório src no campo de edição do assistente de importação. E que você selecione apenas o diretório "com" na árvore de diretórios esquerda. Não selecione src.
• testemunho
• integração android
• andróide
• Verifique se a sua versão do Android sdk é 9, qualquer coisa menor e o androidmanifest.xml irá chorar.
• Strings.xml em um dos idiomas será exibido, basta colocar um / antes do caractere '

Um projeto android para zxing 1.7 (checkout em 20 de junho).

http://www.4shared.com/file/bFx8Y5Ys/zXingJune2010.html ( NÃO DISPONÍVEL MAIS )

Por que usar uma lib externa, quando o google play services (desde a versão 7.8.0 ) inclui um decodificador de código de barras.

Acabei de escrever um método, que decodifica códigos de barras gerados, Bitmappara String.

Faz exatamente o que está sendo solicitado, apenas sem o CaptureActivity...

Portanto, pode-se pular a android-integrationbiblioteca no 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')
}

O método a seguir (que realmente decodifica códigos de barras gerados, dentro de um teste 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 como um encanto, fácil de integrar e usar. https://github.com/dm77/barcodescanner

Recentemente, usei a visão móvel do Google no iOS e no Android. Eu recomendo usar o Google Barcode Scan. É bastante responsivo com qualquer orientação e o tempo de processamento é bastante rápido. É chamado Google Mobile Vision.

A API do Barcode Scanner detecta códigos de barras em tempo real em qualquer orientação. Você também pode detectar e analisar vários códigos de barras em diferentes formatos ao mesmo tempo.

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

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

Abordagem muito mais fácil.

Basta incluir dependência no arquivo gradle no nível do aplicativo

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

Defina um botão no seu arquivo xml e escreva o código abaixo no arquivo Java no OnCreate () e dentro do botão de escuta do OnClick

new IntentIntegrator(this).initiateScan();

E escreva o código abaixo após OnCreate () do arquivo 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();

        }
    }

}

ATUALIZAÇÃO 2020: Adicione isso ao seu arquivo Gradle. Funciona perfeitamente!

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