diff --git a/README.md b/README.md
index 85ae5c821..f8a2030cb 100644
--- a/README.md
+++ b/README.md
@@ -100,48 +100,45 @@ Make sure it is enabled in your manifest file:
     <application android:hardwareAccelerated="true" ... >
 ```
 
-## Usage with IntentIntegrator
+## Usage with ScanContract
 
-Launch the intent with the default options:
-```java
-new IntentIntegrator(this).initiateScan(); // `this` is the current Activity
-
-
-// Get the results:
-@Override
-protected void onActivityResult(int requestCode, int resultCode, Intent data) {
-    IntentResult result = IntentIntegrator.parseActivityResult(requestCode, resultCode, data);
-    if(result != null) {
-        if(result.getContents() == null) {
-            Toast.makeText(this, "Cancelled", Toast.LENGTH_LONG).show();
-        } else {
-            Toast.makeText(this, "Scanned: " + result.getContents(), Toast.LENGTH_LONG).show();
-        }
-    } else {
-        super.onActivityResult(requestCode, resultCode, data);
-    }
-}
-```
+Note: `startActivityForResult` is deprecated, so this example uses `registerForActivityResult` instead.
+See for details: https://developer.android.com/training/basics/intents/result
 
-Use from a Fragment:
-```java
-IntentIntegrator.forFragment(this).initiateScan(); // `this` is the current Fragment
+`startActivityForResult` can still be used via `IntentIntegrator`, but that is not recommended anymore.
 
-// If you're using the support library, use IntentIntegrator.forSupportFragment(this) instead.
+```java
+    // Note: startActivityForResult is deprecated, so this example uses registerForActivityResult instead.
+    // See for details: https://developer.android.com/training/basics/intents/result
+
+    // Register the launcher and result handler
+    private final ActivityResultLauncher<ScanOptions> barcodeLauncher = registerForActivityResult(new ScanContract(),
+            result -> {
+                if(result.getContents() == null) {
+                    Toast.makeText(MyActivity.this, "Cancelled", Toast.LENGTH_LONG).show();
+                } else {
+                    Toast.makeText(MyActivity.this, "Scanned: " + result.getContents(), Toast.LENGTH_LONG).show();
+                }
+            });
+
+    // Launch
+    public void onButtonClick(View view) {
+        barcodeLauncher.launch(new ScanOptions());
+    }
 ```
 
 Customize options:
 ```java
-IntentIntegrator integrator = new IntentIntegrator(this);
-integrator.setDesiredBarcodeFormats(IntentIntegrator.ONE_D_CODE_TYPES);
-integrator.setPrompt("Scan a barcode");
-integrator.setCameraId(0);  // Use a specific camera of the device
-integrator.setBeepEnabled(false);
-integrator.setBarcodeImageEnabled(true);
-integrator.initiateScan();
+ScanOptions options = new ScanOptions();
+options.setDesiredBarcodeFormats(ScanOptions.ONE_D_CODE_TYPES);
+options.setPrompt("Scan a barcode");
+options.setCameraId(0);  // Use a specific camera of the device
+options.setBeepEnabled(false);
+options.setBarcodeImageEnabled(true);
+barcodeLauncher.launch(options);
 ```
 
-See [IntentIntegrator][5] for more options.
+See [BarcodeOptions][5] for more options.
 
 ### Generate Barcode example
 
@@ -177,9 +174,9 @@ Sample:
 ```
 
 ```java
-IntentIntegrator integrator = new IntentIntegrator(this);
-integrator.setOrientationLocked(false);
-integrator.initiateScan();
+ScanOptions options = new ScanOptions();
+options.setOrientationLocked(false);
+barcodeLauncher.launch(options);
 ```
 
 ### Customization and advanced options
@@ -223,7 +220,7 @@ You can then use your local version by specifying in your `build.gradle` file:
 
 Licensed under the [Apache License 2.0][7]
 
-	Copyright (C) 2012-2018 ZXing authors, Journey Mobile
+	Copyright (C) 2012-201 ZXing authors, Journey Mobile
 
 	Licensed under the Apache License, Version 2.0 (the "License");
 	you may not use this file except in compliance with the License.
@@ -241,7 +238,5 @@ Licensed under the [Apache License 2.0][7]
 
 [1]: http://journeyapps.com
 [2]: https://github.com/zxing/zxing/
-[3]: https://github.com/zxing/zxing/wiki/Scanning-Via-Intent
-[4]: https://github.com/journeyapps/zxing-android-embedded/blob/2.x/README.md
-[5]: zxing-android-embedded/src/com/google/zxing/integration/android/IntentIntegrator.java
+[5]: zxing-android-embedded/src/com/journeyapps/barcodescanner/ScanOptions.java
 [7]: http://www.apache.org/licenses/LICENSE-2.0
diff --git a/build.gradle b/build.gradle
index 20a4ac7cb..b33070f45 100644
--- a/build.gradle
+++ b/build.gradle
@@ -19,6 +19,6 @@ subprojects {
     version = '4.2.0'
     group = 'com.journeyapps'
 
-    ext.androidTargetSdk = 28
+    ext.androidTargetSdk = 30
     ext.zxingCore = 'com.google.zxing:core:3.4.1'
 }
diff --git a/sample/build.gradle b/sample/build.gradle
index 0dcb9eb38..a7bcfbdd8 100644
--- a/sample/build.gradle
+++ b/sample/build.gradle
@@ -65,16 +65,17 @@ dependencies {
     implementation project(':zxing-android-embedded')
 
     implementation 'androidx.appcompat:appcompat:1.3.1'
-    implementation "androidx.legacy:legacy-support-v13:1.0.0"
+    implementation 'androidx.legacy:legacy-support-v13:1.0.0'
+    implementation "androidx.activity:activity:1.3.1"
 
     // Desugaring and multidex is required for API < 21.
     coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.1.5'
-    implementation "androidx.multidex:multidex:2.0.1"
+    implementation 'androidx.multidex:multidex:2.0.1'
 
     // leakcanary is for development purposes only
     // https://github.com/square/leakcanary
     debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.7'
 
     // AboutLibraries
-    implementation "com.mikepenz:aboutlibraries:6.2.3"
+    implementation 'com.mikepenz:aboutlibraries:6.2.3'
 }
diff --git a/sample/src/main/java/example/zxing/MainActivity.java b/sample/src/main/java/example/zxing/MainActivity.java
index 99a3b6204..1b3c791eb 100644
--- a/sample/src/main/java/example/zxing/MainActivity.java
+++ b/sample/src/main/java/example/zxing/MainActivity.java
@@ -3,8 +3,6 @@
 import android.content.Intent;
 import android.hardware.Camera;
 import android.os.Bundle;
-import androidx.fragment.app.Fragment;
-import androidx.appcompat.app.AppCompatActivity;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
@@ -13,14 +11,33 @@
 import android.widget.Toast;
 
 import com.google.zxing.client.android.Intents;
-import com.google.zxing.integration.android.IntentIntegrator;
-import com.google.zxing.integration.android.IntentResult;
+import com.journeyapps.barcodescanner.ScanContract;
+import com.journeyapps.barcodescanner.ScanOptions;
 import com.mikepenz.aboutlibraries.LibsBuilder;
 
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.fragment.app.Fragment;
+
 
 public class MainActivity extends AppCompatActivity {
+    private final ActivityResultLauncher<ScanOptions> barcodeLauncher = registerForActivityResult(new ScanContract(),
+            result -> {
+                if(result.getContents() == null) {
+                    Intent originalIntent = result.getOriginalIntent();
+                    if (originalIntent == null) {
+                        Log.d("MainActivity", "Cancelled scan");
+                        Toast.makeText(MainActivity.this, "Cancelled", Toast.LENGTH_LONG).show();
+                    } else if(originalIntent.hasExtra(Intents.Scan.MISSING_CAMERA_PERMISSION)) {
+                        Log.d("MainActivity", "Cancelled scan due to missing camera permission");
+                        Toast.makeText(MainActivity.this, "Cancelled due to missing camera permission", Toast.LENGTH_LONG).show();
+                    }
+                } else {
+                    Log.d("MainActivity", "Scanned");
+                    Toast.makeText(MainActivity.this, "Scanned: " + result.getContents(), Toast.LENGTH_LONG).show();
+                }
+            });
 
-    public final int CUSTOMIZED_REQUEST_CODE = 0x0000ffff;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -29,49 +46,45 @@ protected void onCreate(Bundle savedInstanceState) {
     }
 
     public void scanBarcode(View view) {
-        new IntentIntegrator(this).initiateScan();
-    }
-
-    public void scanBarcodeWithCustomizedRequestCode(View view) {
-        new IntentIntegrator(this).setRequestCode(CUSTOMIZED_REQUEST_CODE).initiateScan();
+        barcodeLauncher.launch(new ScanOptions());
     }
 
     public void scanBarcodeInverted(View view){
-        IntentIntegrator integrator = new IntentIntegrator(this);
-        integrator.addExtra(Intents.Scan.SCAN_TYPE, Intents.Scan.INVERTED_SCAN);
-        integrator.initiateScan();
+        ScanOptions options = new ScanOptions();
+        options.addExtra(Intents.Scan.SCAN_TYPE, Intents.Scan.INVERTED_SCAN);
+        barcodeLauncher.launch(options);
     }
 
     public void scanMixedBarcodes(View view){
-        IntentIntegrator integrator = new IntentIntegrator(this);
-        integrator.addExtra(Intents.Scan.SCAN_TYPE, Intents.Scan.MIXED_SCAN);
-        integrator.initiateScan();
+        ScanOptions options = new ScanOptions();
+        options.addExtra(Intents.Scan.SCAN_TYPE, Intents.Scan.MIXED_SCAN);
+        barcodeLauncher.launch(options);
     }
 
     public void scanBarcodeCustomLayout(View view) {
-        IntentIntegrator integrator = new IntentIntegrator(this);
-        integrator.setCaptureActivity(AnyOrientationCaptureActivity.class);
-        integrator.setDesiredBarcodeFormats(IntentIntegrator.ONE_D_CODE_TYPES);
-        integrator.setPrompt("Scan something");
-        integrator.setOrientationLocked(false);
-        integrator.setBeepEnabled(false);
-        integrator.initiateScan();
+        ScanOptions options = new ScanOptions();
+        options.setCaptureActivity(AnyOrientationCaptureActivity.class);
+        options.setDesiredBarcodeFormats(ScanOptions.ONE_D_CODE_TYPES);
+        options.setPrompt("Scan something");
+        options.setOrientationLocked(false);
+        options.setBeepEnabled(false);
+        barcodeLauncher.launch(options);
     }
 
     public void scanPDF417(View view) {
-        IntentIntegrator integrator = new IntentIntegrator(this);
-        integrator.setDesiredBarcodeFormats(IntentIntegrator.PDF_417);
-        integrator.setPrompt("Scan something");
-        integrator.setOrientationLocked(false);
-        integrator.setBeepEnabled(false);
-        integrator.initiateScan();
+        ScanOptions options = new ScanOptions();
+        options.setDesiredBarcodeFormats(ScanOptions.PDF_417);
+        options.setPrompt("Scan something");
+        options.setOrientationLocked(false);
+        options.setBeepEnabled(false);
+        barcodeLauncher.launch(options);
     }
 
 
     public void scanBarcodeFrontCamera(View view) {
-        IntentIntegrator integrator = new IntentIntegrator(this);
-        integrator.setCameraId(Camera.CameraInfo.CAMERA_FACING_FRONT);
-        integrator.initiateScan();
+        ScanOptions options = new ScanOptions();
+        options.setCameraId(Camera.CameraInfo.CAMERA_FACING_FRONT);
+        barcodeLauncher.launch(options);
     }
 
     public void scanContinuous(View view) {
@@ -80,24 +93,26 @@ public void scanContinuous(View view) {
     }
 
     public void scanToolbar(View view) {
-        new IntentIntegrator(this).setCaptureActivity(ToolbarCaptureActivity.class).initiateScan();
+        ScanOptions options = new ScanOptions().setCaptureActivity(ToolbarCaptureActivity.class);
+        barcodeLauncher.launch(options);
     }
 
     public void scanCustomScanner(View view) {
-        new IntentIntegrator(this).setOrientationLocked(false).setCaptureActivity(CustomScannerActivity.class).initiateScan();
+        ScanOptions options = new ScanOptions().setOrientationLocked(false).setCaptureActivity(CustomScannerActivity.class);
+        barcodeLauncher.launch(options);
     }
 
     public void scanMarginScanner(View view) {
-        IntentIntegrator integrator = new IntentIntegrator(this);
-        integrator.setOrientationLocked(false);
-        integrator.setCaptureActivity(SmallCaptureActivity.class);
-        integrator.initiateScan();
+        ScanOptions options = new ScanOptions();
+        options.setOrientationLocked(false);
+        options.setCaptureActivity(SmallCaptureActivity.class);
+        barcodeLauncher.launch(options);
     }
 
     public void scanWithTimeout(View view) {
-        IntentIntegrator integrator = new IntentIntegrator(this);
-        integrator.setTimeout(8000);
-        integrator.initiateScan();
+        ScanOptions options = new ScanOptions();
+        options.setTimeout(8000);
+        barcodeLauncher.launch(options);
     }
 
     public void tabs(View view) {
@@ -109,45 +124,24 @@ public void about(View view) {
         new LibsBuilder().start(this);
     }
 
-    @Override
-    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
-        if (requestCode != CUSTOMIZED_REQUEST_CODE && requestCode != IntentIntegrator.REQUEST_CODE) {
-            // This is important, otherwise the result will not be passed to the fragment
-            super.onActivityResult(requestCode, resultCode, data);
-            return;
-        }
-        switch (requestCode) {
-            case CUSTOMIZED_REQUEST_CODE: {
-                Toast.makeText(this, "REQUEST_CODE = " + requestCode, Toast.LENGTH_LONG).show();
-                break;
-            }
-            default:
-                break;
-        }
-
-        IntentResult result = IntentIntegrator.parseActivityResult(resultCode, data);
-
-        if(result.getContents() == null) {
-            Intent originalIntent = result.getOriginalIntent();
-            if (originalIntent == null) {
-                Log.d("MainActivity", "Cancelled scan");
-                Toast.makeText(this, "Cancelled", Toast.LENGTH_LONG).show();
-            } else if(originalIntent.hasExtra(Intents.Scan.MISSING_CAMERA_PERMISSION)) {
-                Log.d("MainActivity", "Cancelled scan due to missing camera permission");
-                Toast.makeText(this, "Cancelled due to missing camera permission", Toast.LENGTH_LONG).show();
-            }
-        } else {
-            Log.d("MainActivity", "Scanned");
-            Toast.makeText(this, "Scanned: " + result.getContents(), Toast.LENGTH_LONG).show();
-        }
-    }
-
     /**
      * Sample of scanning from a Fragment
      */
     public static class ScanFragment extends Fragment {
         private String toast;
 
+        private final ActivityResultLauncher<ScanOptions> fragmentLauncher = registerForActivityResult(new ScanContract(),
+                result -> {
+                    if(result.getContents() == null) {
+                        toast = "Cancelled from fragment";
+                    } else {
+                        toast = "Scanned from fragment: " + result.getContents();
+                    }
+
+                    // At this point we may or may not have a reference to the activity
+                    displayToast();
+                });
+
         public ScanFragment() {
         }
 
@@ -168,7 +162,7 @@ public View onCreateView(LayoutInflater inflater, ViewGroup container,
         }
 
         public void scanFromFragment() {
-            IntentIntegrator.forSupportFragment(this).initiateScan();
+            fragmentLauncher.launch(new ScanOptions());
         }
 
         private void displayToast() {
@@ -177,20 +171,5 @@ private void displayToast() {
                 toast = null;
             }
         }
-
-        @Override
-        public void onActivityResult(int requestCode, int resultCode, Intent data) {
-            IntentResult result = IntentIntegrator.parseActivityResult(requestCode, resultCode, data);
-            if(result != null) {
-                if(result.getContents() == null) {
-                    toast = "Cancelled from fragment";
-                } else {
-                    toast = "Scanned from fragment: " + result.getContents();
-                }
-
-                // At this point we may or may not have a reference to the activity
-                displayToast();
-            }
-        }
     }
 }
diff --git a/sample/src/main/res/layout/activity_main.xml b/sample/src/main/res/layout/activity_main.xml
index 3210cfd61..26749d4d3 100644
--- a/sample/src/main/res/layout/activity_main.xml
+++ b/sample/src/main/res/layout/activity_main.xml
@@ -25,12 +25,6 @@
             android:text="Scan PDF417"
             android:onClick="scanPDF417"/>
 
-        <Button
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:text="@string/scan_barcode_with_request_code"
-            android:onClick="scanBarcodeWithCustomizedRequestCode"/>
-
         <Button
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
diff --git a/zxing-android-embedded/src/com/google/zxing/integration/android/IntentIntegrator.java b/zxing-android-embedded/src/com/google/zxing/integration/android/IntentIntegrator.java
index 928282182..e40dc9cac 100644
--- a/zxing-android-embedded/src/com/google/zxing/integration/android/IntentIntegrator.java
+++ b/zxing-android-embedded/src/com/google/zxing/integration/android/IntentIntegrator.java
@@ -39,6 +39,7 @@
  * @author Isaac Potoczny-Jones
  * @author Brad Drehmer
  * @author gcstang
+ * @deprecated Use ScanOptions and ScanContract instead.
  */
 @SuppressWarnings("unused")
 public class IntentIntegrator {
@@ -353,6 +354,7 @@ protected void startActivity(Intent intent) {
      * @return null if the event handled here was not related to this class, or
      * else an {@link IntentResult} containing the result of the scan. If the user cancelled scanning,
      * the fields will be null.
+     * @deprecated Not compatible with setRequestCode(). Use parseActivityResult(resultCode, intent) instead.
      */
     public static IntentResult parseActivityResult(int requestCode, int resultCode, Intent intent) {
         if (requestCode == REQUEST_CODE) {
diff --git a/zxing-android-embedded/src/com/journeyapps/barcodescanner/ScanContract.java b/zxing-android-embedded/src/com/journeyapps/barcodescanner/ScanContract.java
new file mode 100644
index 000000000..10e46e6fd
--- /dev/null
+++ b/zxing-android-embedded/src/com/journeyapps/barcodescanner/ScanContract.java
@@ -0,0 +1,21 @@
+package com.journeyapps.barcodescanner;
+
+import android.content.Context;
+import android.content.Intent;
+
+import androidx.activity.result.contract.ActivityResultContract;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public class ScanContract extends ActivityResultContract<ScanOptions, ScanIntentResult> {
+    @NonNull
+    @Override
+    public Intent createIntent(@NonNull Context context, ScanOptions input) {
+        return input.createScanIntent(context);
+    }
+
+    @Override
+    public ScanIntentResult parseResult(int resultCode, @Nullable Intent intent) {
+        return ScanIntentResult.parseActivityResult(resultCode, intent);
+    }
+}
diff --git a/zxing-android-embedded/src/com/journeyapps/barcodescanner/ScanIntentResult.java b/zxing-android-embedded/src/com/journeyapps/barcodescanner/ScanIntentResult.java
new file mode 100644
index 000000000..0adde4bed
--- /dev/null
+++ b/zxing-android-embedded/src/com/journeyapps/barcodescanner/ScanIntentResult.java
@@ -0,0 +1,155 @@
+/*
+ * Based on IntentResult.
+ *
+ * Copyright 2009 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.
+ */
+
+package com.journeyapps.barcodescanner;
+
+import android.app.Activity;
+import android.content.Intent;
+
+import com.google.zxing.client.android.Intents;
+import com.google.zxing.integration.android.IntentResult;
+
+/**
+ * <p>Encapsulates the result of a barcode scan invoked through {@link ScanContract}.</p>
+ *
+ * @author Sean Owen
+ */
+public final class ScanIntentResult {
+
+    private final String contents;
+    private final String formatName;
+    private final byte[] rawBytes;
+    private final Integer orientation;
+    private final String errorCorrectionLevel;
+    private final String barcodeImagePath;
+    private final Intent originalIntent;
+
+    ScanIntentResult() {
+        this(null, null, null, null, null, null, null);
+    }
+
+    ScanIntentResult(Intent intent) {
+        this(null, null, null, null, null, null, intent);
+    }
+
+    ScanIntentResult(String contents,
+                     String formatName,
+                     byte[] rawBytes,
+                     Integer orientation,
+                     String errorCorrectionLevel,
+                     String barcodeImagePath,
+                     Intent originalIntent) {
+        this.contents = contents;
+        this.formatName = formatName;
+        this.rawBytes = rawBytes;
+        this.orientation = orientation;
+        this.errorCorrectionLevel = errorCorrectionLevel;
+        this.barcodeImagePath = barcodeImagePath;
+        this.originalIntent = originalIntent;
+    }
+
+    /**
+     * @return raw content of barcode
+     */
+    public String getContents() {
+        return contents;
+    }
+
+    /**
+     * @return name of format, like "QR_CODE", "UPC_A". See {@code BarcodeFormat} for more format names.
+     */
+    public String getFormatName() {
+        return formatName;
+    }
+
+    /**
+     * @return raw bytes of the barcode content, if applicable, or null otherwise
+     */
+    public byte[] getRawBytes() {
+        return rawBytes;
+    }
+
+    /**
+     * @return rotation of the image, in degrees, which resulted in a successful scan. May be null.
+     */
+    public Integer getOrientation() {
+        return orientation;
+    }
+
+    /**
+     * @return name of the error correction level used in the barcode, if applicable
+     */
+    public String getErrorCorrectionLevel() {
+        return errorCorrectionLevel;
+    }
+
+    /**
+     * @return path to a temporary file containing the barcode image, if applicable, or null otherwise
+     */
+    public String getBarcodeImagePath() {
+        return barcodeImagePath;
+    }
+
+    /**
+     * @return the original intent
+     */
+    public Intent getOriginalIntent() {
+        return originalIntent;
+    }
+
+    @Override
+    public String toString() {
+        int rawBytesLength = rawBytes == null ? 0 : rawBytes.length;
+        return "Format: " + formatName + '\n' +
+            "Contents: " + contents + '\n' +
+            "Raw bytes: (" + rawBytesLength + " bytes)\n" +
+            "Orientation: " + orientation + '\n' +
+            "EC level: " + errorCorrectionLevel + '\n' +
+            "Barcode image: " + barcodeImagePath + '\n' +
+            "Original intent: " + originalIntent + '\n';
+    }
+
+
+    /**
+     * Parse activity result, without checking the request code.
+     *
+     * @param resultCode result code from {@code onActivityResult()}
+     * @param intent     {@link Intent} from {@code onActivityResult()}
+     * @return an {@link IntentResult} containing the result of the scan. If the user cancelled scanning,
+     * the fields will be null.
+     */
+    public static ScanIntentResult parseActivityResult(int resultCode, Intent intent) {
+        if (resultCode == Activity.RESULT_OK) {
+            String contents = intent.getStringExtra(Intents.Scan.RESULT);
+            String formatName = intent.getStringExtra(Intents.Scan.RESULT_FORMAT);
+            byte[] rawBytes = intent.getByteArrayExtra(Intents.Scan.RESULT_BYTES);
+            int intentOrientation = intent.getIntExtra(Intents.Scan.RESULT_ORIENTATION, Integer.MIN_VALUE);
+            Integer orientation = intentOrientation == Integer.MIN_VALUE ? null : intentOrientation;
+            String errorCorrectionLevel = intent.getStringExtra(Intents.Scan.RESULT_ERROR_CORRECTION_LEVEL);
+            String barcodeImagePath = intent.getStringExtra(Intents.Scan.RESULT_BARCODE_IMAGE_PATH);
+            return new ScanIntentResult(contents,
+                    formatName,
+                    rawBytes,
+                    orientation,
+                    errorCorrectionLevel,
+                    barcodeImagePath,
+                    intent);
+        }
+        return new ScanIntentResult(intent);
+    }
+}
diff --git a/zxing-android-embedded/src/com/journeyapps/barcodescanner/ScanOptions.java b/zxing-android-embedded/src/com/journeyapps/barcodescanner/ScanOptions.java
new file mode 100644
index 000000000..2362317df
--- /dev/null
+++ b/zxing-android-embedded/src/com/journeyapps/barcodescanner/ScanOptions.java
@@ -0,0 +1,262 @@
+/*
+ * Based on IntentIntegrator, Copyright 2009 ZXing authors.
+ *
+ */
+package com.journeyapps.barcodescanner;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.google.zxing.client.android.Intents;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ScanOptions {
+    // supported barcode formats
+
+    // Product Codes
+    public static final String UPC_A = "UPC_A";
+    public static final String UPC_E = "UPC_E";
+    public static final String EAN_8 = "EAN_8";
+    public static final String EAN_13 = "EAN_13";
+    public static final String RSS_14 = "RSS_14";
+
+    // Other 1D
+    public static final String CODE_39 = "CODE_39";
+    public static final String CODE_93 = "CODE_93";
+    public static final String CODE_128 = "CODE_128";
+    public static final String ITF = "ITF";
+
+    public static final String RSS_EXPANDED = "RSS_EXPANDED";
+
+    // 2D
+    public static final String QR_CODE = "QR_CODE";
+    public static final String DATA_MATRIX = "DATA_MATRIX";
+    public static final String PDF_417 = "PDF_417";
+
+
+    public static final Collection<String> PRODUCT_CODE_TYPES = list(UPC_A, UPC_E, EAN_8, EAN_13, RSS_14);
+    public static final Collection<String> ONE_D_CODE_TYPES =
+            list(UPC_A, UPC_E, EAN_8, EAN_13, RSS_14, CODE_39, CODE_93, CODE_128,
+                    ITF, RSS_14, RSS_EXPANDED);
+
+    public static final Collection<String> ALL_CODE_TYPES = null;
+
+    private final Map<String, Object> moreExtras = new HashMap<>(3);
+
+    private Collection<String> desiredBarcodeFormats;
+
+    private Class<?> captureActivity;
+
+
+    protected Class<?> getDefaultCaptureActivity() {
+        return CaptureActivity.class;
+    }
+
+    public ScanOptions() {
+
+    }
+
+
+    public Class<?> getCaptureActivity() {
+        if (captureActivity == null) {
+            captureActivity = getDefaultCaptureActivity();
+        }
+        return captureActivity;
+    }
+
+    /**
+     * Set the Activity class to use. It can be any activity, but should handle the intent extras
+     * as used here.
+     *
+     * @param captureActivity the class
+     */
+    public ScanOptions setCaptureActivity(Class<?> captureActivity) {
+        this.captureActivity = captureActivity;
+        return this;
+    }
+
+    public Map<String, ?> getMoreExtras() {
+        return moreExtras;
+    }
+
+    public final ScanOptions addExtra(String key, Object value) {
+        moreExtras.put(key, value);
+        return this;
+    }
+
+    /**
+     * Set a prompt to display on the capture screen, instead of using the default.
+     *
+     * @param prompt the prompt to display
+     */
+    public final ScanOptions setPrompt(String prompt) {
+        if (prompt != null) {
+            addExtra(Intents.Scan.PROMPT_MESSAGE, prompt);
+        }
+        return this;
+    }
+
+    /**
+     * By default, the orientation is locked. Set to false to not lock.
+     *
+     * @param locked true to lock orientation
+     */
+    public ScanOptions setOrientationLocked(boolean locked) {
+        addExtra(Intents.Scan.ORIENTATION_LOCKED, locked);
+        return this;
+    }
+
+    /**
+     * Use the specified camera ID.
+     *
+     * @param cameraId camera ID of the camera to use. A negative value means "no preference".
+     * @return this
+     */
+    public ScanOptions setCameraId(int cameraId) {
+        if (cameraId >= 0) {
+            addExtra(Intents.Scan.CAMERA_ID, cameraId);
+        }
+        return this;
+    }
+
+    /**
+     * Set to true to enable initial torch
+     *
+     * @param enabled true to enable initial torch
+     * @return this
+     */
+    public ScanOptions setTorchEnabled(boolean enabled) {
+        addExtra(Intents.Scan.TORCH_ENABLED, enabled);
+        return this;
+    }
+
+
+    /**
+     * Set to false to disable beep on scan.
+     *
+     * @param enabled false to disable beep
+     * @return this
+     */
+    public ScanOptions setBeepEnabled(boolean enabled) {
+        addExtra(Intents.Scan.BEEP_ENABLED, enabled);
+        return this;
+    }
+
+    /**
+     * Set to true to enable saving the barcode image and sending its path in the result Intent.
+     *
+     * @param enabled true to enable barcode image
+     * @return this
+     */
+    public ScanOptions setBarcodeImageEnabled(boolean enabled) {
+        addExtra(Intents.Scan.BARCODE_IMAGE_ENABLED, enabled);
+        return this;
+    }
+
+    /**
+     * Set the desired barcode formats to scan.
+     *
+     * @param desiredBarcodeFormats names of {@code BarcodeFormat}s to scan for
+     * @return this
+     */
+    public ScanOptions setDesiredBarcodeFormats(Collection<String> desiredBarcodeFormats) {
+        this.desiredBarcodeFormats = desiredBarcodeFormats;
+        return this;
+    }
+
+    /**
+     * Set the desired barcode formats to scan.
+     *
+     * @param desiredBarcodeFormats names of {@code BarcodeFormat}s to scan for
+     * @return this
+     */
+    public ScanOptions setDesiredBarcodeFormats(String... desiredBarcodeFormats) {
+        this.desiredBarcodeFormats = Arrays.asList(desiredBarcodeFormats);
+        return this;
+    }
+
+    /**
+     * Initiates a scan for all known barcode types with the default camera.
+     * And starts a timer to finish on timeout
+     *
+     * @return Activity.RESULT_CANCELED and true on parameter TIMEOUT.
+     */
+    public ScanOptions setTimeout(long timeout) {
+        addExtra(Intents.Scan.TIMEOUT, timeout);
+        return this;
+    }
+
+    /**
+     * Create an scan intent with the specified options.
+     *
+     * @return the intent
+     */
+    public Intent createScanIntent(Context context) {
+        Intent intentScan = new Intent(context, getCaptureActivity());
+        intentScan.setAction(Intents.Scan.ACTION);
+
+        // check which types of codes to scan for
+        if (desiredBarcodeFormats != null) {
+            // set the desired barcode types
+            StringBuilder joinedByComma = new StringBuilder();
+            for (String format : desiredBarcodeFormats) {
+                if (joinedByComma.length() > 0) {
+                    joinedByComma.append(',');
+                }
+                joinedByComma.append(format);
+            }
+            intentScan.putExtra(Intents.Scan.FORMATS, joinedByComma.toString());
+        }
+
+        intentScan.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        intentScan.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
+        attachMoreExtras(intentScan);
+        return intentScan;
+    }
+
+    private static List<String> list(String... values) {
+        return Collections.unmodifiableList(Arrays.asList(values));
+    }
+
+    private void attachMoreExtras(Intent intent) {
+        for (Map.Entry<String, Object> entry : moreExtras.entrySet()) {
+            String key = entry.getKey();
+            Object value = entry.getValue();
+            // Kind of hacky
+            if (value instanceof Integer) {
+                intent.putExtra(key, (Integer) value);
+            } else if (value instanceof Long) {
+                intent.putExtra(key, (Long) value);
+            } else if (value instanceof Boolean) {
+                intent.putExtra(key, (Boolean) value);
+            } else if (value instanceof Double) {
+                intent.putExtra(key, (Double) value);
+            } else if (value instanceof Float) {
+                intent.putExtra(key, (Float) value);
+            } else if (value instanceof Bundle) {
+                intent.putExtra(key, (Bundle) value);
+            } else if (value instanceof int[]) {
+                intent.putExtra(key, (int[]) value);
+            } else if (value instanceof long[]) {
+                intent.putExtra(key, (long[]) value);
+            } else if (value instanceof boolean[]) {
+                intent.putExtra(key, (boolean[]) value);
+            } else if (value instanceof double[]) {
+                intent.putExtra(key, (double[]) value);
+            } else if (value instanceof float[]) {
+                intent.putExtra(key, (float[]) value);
+            } else if (value instanceof String[]) {
+                intent.putExtra(key, (String[]) value);
+            } else {
+                intent.putExtra(key, value.toString());
+            }
+        }
+    }
+}