Forem: Michael Chiew

Guide To Leverage The Built-in Barcode Scanners on Android PDAs with Flutter

Michael Chiew — Mon, 10 Nov 2025 13:56:38 +0000

Ever wonder how you can leverage those built-in barcode scanner or sometimes it is called as PDA handheld scanners that runs on Android operating system in your Flutter app?

You are in luck! This guide introduce you the flutter_pda_scanner_v2 package which is designed to help you to integrate into your Flutter app and operate the barcode scanner.

Before we dive right in, I have to first clarify that the package is originally fork or reference it from flutter_pda_scanner and pda_scanner.

Due to the lack of update and response from the predecessor, therefore I choose to separate out the repository to include certain new enhancement such as supporting Android V2 Embedding and also include a wider range of compatibility with the latest Android PDA device models.

There are also other viable alternatives that work in similar fashion, hence you can still choose whatever that best fits you.

The installation process is pretty straightforward.

Firstly, add the package into your dependencies. Version may vary as time goes on, please check with the latest version.

dependencies:
  flutter_pda_scanner_v2: ^0.0.5

Go to your main.dart file or the one that contains your main method, include the package import and then add await PdaScanner.instance.initialize(); into the main method right after the WidgetFlutterBinding.ensureInitialized();

/// Import package of `flutter_pda_scanner_v2.dart`
import 'package:flutter_pda_scanner_v2/flutter_pda_scanner_v2.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  // Initialize the PdaScanner.
  await PdaScanner.instance.initialize();
  runApp(const MyApp());
}

After that, go to your respective screen or widget that you want to include to listen to the scanning capability. Make sure you import the package. Finally, add both @override method of onEvent and onError

/// Import package of `flutter_pda_scanner_v2.dart`
import 'package:flutter_pda_scanner_v2/flutter_pda_scanner_v2.dart';

class ScreenExampleState extends State<ScreenExample> with PdaListenerMixin<ScreenExample> {
  var _code;

  @override
  Widget build(BuildContext context) {
    return null;
    // Or return your own widget.
  }

  // Add these @override methods to listen to scanner events.
  @override
  void onEvent(Object event) {
      // Process the value of the `event.toString()` here.
  }

  @override
  void onError(Object error) {
      // Process the value of the `error.toString()` here such as show toast or dialog.
  }
}

There you have it! When you tap on the proprietary barcode scanning button, it should flash out a placeholder in order to find and capture the barcode. Once it captured the correct input, it should make a “beep” sound.

The device that shown in the GIF above is using SEUIC AutoID Q9 that runs on Android 10

What do you think? Please share your thought and your feedback down below on how flutter_pda_scanner_v2 package is enhancing your development experience.

If it does, a simple👏🏻 to this post would be appreciated!

Thank you for taking the time to read!

*Original post from Medium which is also my own post: https://medium.com/@michaelchiew/guide-to-leverage-the-built-in-barcode-scanners-on-android-pdas-with-flutter-13fc49116e8a

Flutter Migration Guide: Preparing Your Android App for Google Play’s 16 KB Page-Size Requirement

Michael Chiew — Mon, 27 Oct 2025 03:28:33 +0000

🚨 DEADLINE ALERT! 🚨
November 1, 2025 is just around the corner!
Google Play is enforcing the 16 KB page size requirement — and your Flutter app might need an update to stay compliant.

As you may have seen it on the cover photo above which is about the latest Google Play’s 16 KB page size requirement that is affecting the app. Whereby starting November 1, 2025, all the new app submission must support the new 16 KB page size requirement and must support the target SDK 35 / API 35 or also known as Android 15 and above (this is extended deadline).

Hence, this raised a question on what should a Flutter developer needs to do to ensure the future release is supporting 16 KB page size, and also how we can verify the app is actually supporting 16 KB page size after performing the upgrade (including the package dependencies upgrade) ?

To shed some lights, I recently managed to upgrade one of my own personal Flutter app and also helped my workplace to kickstart the upgrade as well to support 16 KB page size requirement. Initially, the Flutter SDK version for the app was 3.19.5 and then I upgraded to 3.32.8 which I believe this should also required to upgrade the Gradle dependency version. Technically Flutter 3.32.X and above should be aligned with to support 16 KB page size requirement.

To get things out of the way,

1.) Locate your android/build.gradle file, upgrade Kotlin version 2.2.10 and the build gradle tools to 8.12.2

buildscript {
    ext.kotlin_version = '2.2.10'
    repositories {
        google()
        mavenCentral()
    }

    dependencies {
        classpath 'com.android.tools.build:gradle:8.12.2'
        // ... rest of your code

    }
}

2.) Then locate your android/gradle/wrapper/gradle-wrapper.properties file and change the distributionUrl value to fetch gradle-8.13-all.zip

distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-all.zip

3.) Make sure your android/settings.gradle also upgrade to 8.12.2 and Kotlin Android version to 2.2.10

plugins {
    id "dev.flutter.flutter-plugin-loader" version "1.0.0"
    id "com.android.application" version "8.12.2" apply false
    id "org.jetbrains.kotlin.android" version "2.2.10" apply false
}

include ":app"

4.) Although this could be somewhat optional but in the end you still need to upgrade it anyway, therefore set the targeted SDK to 35 in this android/app/build.gradle file.

android {
    namespace "your.application.id_name"  // make sure this remain your app name
    compileSdk flutter.compileSdkVersion
    ndkVersion flutter.ndkVersion

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    defaultConfig {
        applicationId "your.application.id_name" // make sure this remain your app name
        minSdkVersion 23
        targetSdkVersion 35
        versionCode flutterVersionCode.toInteger()
        versionName flutterVersionName
    }

//... rest of your code

}

Once the all the above 4 items are properly configured, you may start compile the app by running the usual Flutter command to build your .apk file.

flutter build apk --release

And then one final step is we have to do verification by creating a script file in our Flutter project root folder, and name it as check_elf_alignment.sh

Copy the script file code from the link below:
Kudos to the creator 💖 https://gist.github.com/NitinPraksash9911/76f1793785a232b2aa2bc2e409873955

Finally, allow the file to be executable (for MacOS) and then run the script in the terminal like below to verify:

chmod +x check_elf_alignment.sh

./check_alignment_elf.sh build/app/outputs/apk/release/app-release.apk

Once the output shows it is aligned with all the green checkmarks ✅, then you are good to go to generate the App Bundle .aab and submit your app to Google Play Console.

In summary:

Kotlin Version: 2.2.10 and above
Gradle Wrapper: 8.12 and above
Flutter: 3.32 and above
Target Android SDK / API Level: 35 and above
Flutter build APK
Verify the APK with script file check_elf_alignment.sh for 16 KB page size alignment.

If you got any question or would like to have some discussions, please feel free to drop a comment down below. And if you like my very first post content, please give a 👏🏻 to my post.

Much appreciated and a big big thanks!

*Original post from Medium which is also my own post: https://medium.com/@michaelchiew/flutter-migration-guide-preparing-your-android-app-for-google-plays-16-kb-page-size-requirement-8f6d971f7b23