The ColoredButton widget is used to create a button that initiates the scanning of a document, such as a passport or identity card. This button is designed to navigate to the MrzScreen when pressed.
ColoredButton(
onPressed: () {
Navigator.push(
context,
MaterialPageRoute(
builder: (context) => MrzScreen(),
),
);
},
child: const Text(
"Scan Document",
style: TextStyle(
fontWeight: FontWeight.bold,
),
),
iconData: Icons.camera_alt_rounded,
),The following Flutter code snippet demonstrates how to handle camera permission within a Scaffold. This implementation utilizes the permission_handler package.
Scaffold(
appBar: AppBar(),
body: FutureBuilder<PermissionStatus>(
// Request camera permission asynchronously
future: Permission.camera.request(),
builder: (context, snapshot) {
// Check if permission is granted
if (snapshot.hasData && snapshot.data == PermissionStatus.granted) {
// If granted, display the MRZ scanning screen (replace 'MZ()' with your actual MRZ scanning widget)
return MZ();
}
// If permission is permanently denied, prompt the user to enable it in system settings
if (snapshot.data == PermissionStatus.permanentlyDenied) {
openAppSettings(); // Open system settings for the app
}
// If permission is not granted or permanently denied, show a button to request permission
return Center(
child: SizedBox(
child: TextButton(
onPressed: () {
setState(() {});
},
child: Text("Grant Camera Permission"),
),
),
);
},
),
);The MRZScanner widget is a Flutter component designed for extracting Machine Readable Zone (MRZ) data from passports and identity cards. This widget utilizes Google ML Kit Text Recognition and an MRZ Parser library to process images captured by the device's camera.
class MRZScanner extends StatefulWidget {
const MRZScanner({
Key? controller,
required this.onSuccess,
this.initialDirection = CameraLensDirection.back,
this.showOverlay = true,
}) : super(key: controller);
final Function(MRZResult mrzResult, List<String> lines) onSuccess;
final CameraLensDirection initialDirection;
final bool showOverlay;
@override
MRZScannerState createState() => MRZScannerState();
}onSuccess: Callback function invoked when MRZ scanning is successful. It provides an MRZResult object and a list of scanned lines.
initialDirection: Initial direction of the camera lens. Defaults to CameraLensDirection.back.
showOverlay: Boolean flag to determine whether to display the scanning overlay. Defaults to true.
resetScanning(): Resets the scanning state.
_parseScannedText(List lines): Parses the scanned text using the MRZ Parser library.
_processImage(InputImage inputImage): Processes the input image using the Google ML Kit Text Recognition for MRZ scanning.
The following Flutter code demonstrates how to check for NFC availability and handle the initialization of NFC functionality in a Flutter widget.
Future<void> _initPlatformState() async {
// Variable to store NFC availability status
bool isNfcAvailable;
try {
// Get the current NFC status from the platform
NfcStatus status = await NfcProvider.nfcStatus;
isNfcAvailable = status == NfcStatus.enabled;
} on PlatformException {
// An error occurred while checking NFC status, set availability to false
isNfcAvailable = false;
}
// If the widget was removed from the tree while the asynchronous platform
// message was in flight, discard the reply rather than updating the UI.
if (!mounted) return;
// Update the state with the NFC availability status
_isNfcAvailable = isNfcAvailable;
setState(() {});
// Show a Snackbar if NFC is not available
if (_isNfcAvailable == false) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(
content: Text("Couldn't access device NFC, please try again"),
),
);
}
}The _initPlatformState method is used to check the availability of NFC on the device.
The NfcProvider.nfcStatus is called to obtain the current status of NFC.
If the status retrieval is successful, the isNfcAvailable variable is set based on whether NFC is enabled.
If there is an exception (e.g., an error during the status check), isNfcAvailable is set to false.
The _isNfcAvailable state variable is then updated, and the UI is refreshed using setState.
If NFC is not available, a Snackbar is displayed to inform the user.
This demonstrates communication with a chip using dmrtlib and displays relevant data groups from an MRTD (Machine Readable Travel Document). The widget handles the retrieval and display of user data, image, and signature (if present) from Data Groups 1 (DG1), 2 (DG2), and 7 (DG7) respectively.
Chip communication is facilitated through the dmrtlib library. This library enables the widget to interact with the chip to retrieve necessary data from the MRTD and can be see in the /dmrt_lib folder
Data groups DG1, DG2, and DG7 are displayed conditionally based on their presence in the MRTD data. The remaining data groups are hidden with comments and can be shown by uncommenting the relevant code blocks.
// Example code for displaying DG1 data
if (_mrtdData?.dg1 != null) {
list.add(_makeMrtdDataWidget(
header: 'EF.DG1',
collapsedText: '',
dataText: formatDG1(_mrtdData!.dg1!)));
}
// Example code for displaying DG2 data
if (_mrtdData?.dg2 != null) {
list.add(_makeMrtdDataWidget(
header: 'EF.DG2',
collapsedText: '',
dataText: formatDG2(_mrtdData!.dg2!)));
}
// Example code for displaying DG7 data
if (_mrtdData?.dg7 != null) {
list.add(_makeMrtdDataWidget(
header: 'EF.DG7',
collapsedText: '',
dataText: formatDG7(_mrtdData!.dg7!)));
}
Data groups that are not displayed by default are commented out. Uncomment the relevant code blocks to display additional data groups as needed.
Feel free to customize and integrate this code into your project based on the specific requirements of your MRTD reading and data display functionalities.
The following Flutter methods handle image processing, specifically for displaying images in JPG and JPEG2000 formats. These methods are part of a Flutter widget.
This method attempts to display an image in JPG format. If successful, the jpegImage state variable is updated, triggering a widget update.
void tryDisplayingJpg() {
try {
// Set the jpegImage state variable with rawImageData
jpegImage = rawImageData;
setState(() {});
} catch (e) {
// Handle the case when the image is not in JPG format
jpegImage = null;
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text("Image is not in jpg format, trying jpeg2000")));
}
}This method attempts to display an image in JPEG2000 format. It uses the decodeImage function to process the rawImageData asynchronously. If successful, the jp2000Image state variable is updated, triggering a widget update.
void tryDisplayingJp2() async {
try {
// Decode the rawImageData to get jp2000Image
jp2000Image = await decodeImage(rawImageData!, context);
setState(() {});
} catch (e) {
// Handle the case when the image is not in JPEG2000 format
jpegImage = null;
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text("Image is not in jpeg2000")));
}
}
This method utilizes a MethodChannel named 'image_channel' to invoke a platform-specific method for decoding the provided JPEG2000 image data (jp2ImageData). The decoded image data is returned as a Uint8List.
const imageChannel = MethodChannel('image_channel');
Future<Uint8List?> decodeImage(Uint8List jp2ImageData, context) async {
Uint8List? decodedImageData;
try {
// Invoke the platform-specific method for decoding the JPEG2000 image data
final result = await imageChannel.invokeMethod('decodeImage', {'jp2ImageData': jp2ImageData});
// Convert the result to Uint8List
decodedImageData = Uint8List.fromList(result);
} catch (e) {
// Handle any errors during the decoding process
decodedImageData = null;
}
return decodedImageData;
}The following Flutter code snippet demonstrates the handling of image conversion from Data Group 2 (DG2) in a Flutter widget. By default, the JPG conversion is commented out, and the JPEG2000 conversion is not executed.
if (mrtdData.dg2?.imageData != null) {
........
// Uncomment the following line to try displaying the image in JPEG2000 format
tryDisplayingJp2();
}
The following Android code provides an ImageUtil class that handles the decoding of images, specifically supporting JPEG2000 (JP2) format. This class is used in a Flutter project via method channels.
object ImageUtil {
// Decode JP2 image and send the result back to Flutter
fun decodeImage(context: Context?, jp2ImageData: ByteArray, result: MethodChannel.Result) {
// Convert JP2 ByteArray to InputStream
val inputStream: InputStream = ByteArrayInputStream(jp2ImageData)
// Use the existing decodeImage function
val decodedBitmap = decodeImage(context, "image/jp2", inputStream)
// Convert the Bitmap to a ByteArray for sending back to Flutter
val byteArrayOutputStream = ByteArrayOutputStream()
decodedBitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream)
val byteArray = byteArrayOutputStream.toByteArray()
// Send the decoded image back to Flutter
result.success(byteArray)
}
// Decode image based on MIME type
fun decodeImage(context: Context?, mimeType: String, inputStream: InputStream?): Bitmap {
return if (mimeType.equals("image/jp2", ignoreCase = true) || mimeType.equals(
"image/jpeg2000",
ignoreCase = true
)
) {
JP2Decoder(inputStream).decode()
} else {
// Add other decoding logic if needed
BitmapFactory.decodeStream(inputStream)
}
}
}To add delay to the nfc scan method you replace _readMRTD(); within the nfc_reader_screen.dart file: line 704 and adjust the seconds count as required
Future.delayed(Duration(seconds: 2)).then((value) {
_readMRTD();
});
Example
onPressed: () {
_initPlatformState();
Future.delayed(Duration(seconds: 2)).then((value) {
_readMRTD();
});
}