Minha solução abaixo
import 'dart:io';
import 'package:aws_client/rekognition_2016_06_27.dart' as aws;
import 'package:camera/camera.dart';
import 'package:flutter/material.dart';
import 'package:image_picker/image_picker.dart';
import 'package:nonio_ponto/db/usuario.dart';
import 'package:nonio_ponto/db/validacao_facial.dart';
import 'package:quickalert/quickalert.dart';
class AWSRekognitionScreen extends StatefulWidget {
final List<CameraDescription>? cameraDescriptions;
final Usuario? usuario;
final ValidacaoFacial? validacaoFacial;
AWSRekognitionScreen({Key? key, this.cameraDescriptions, this.usuario, this.validacaoFacial}) : super(key: key);
@override
_AWSRekognitionScreenState createState() => _AWSRekognitionScreenState();
}
class _AWSRekognitionScreenState extends State<AWSRekognitionScreen> {
final ImagePicker _picker = ImagePicker();
late CameraController _cameraController;
late Future<void> _initControllerFuture;
// Chaves de acesso (substitua pelas suas)
final _awsAccessKey = "---------";
final _awsSecretKey = "---------";
final _awsRegion = "us-east-1"; // Altere conforme necessário
bool _toggleCamera = false;
Future<void> _analyzeImage(File imageFile) async {
try {
aws.Rekognition rekognition = aws.Rekognition(
region: _awsRegion,
credentials: aws.AwsClientCredentials(
accessKey: _awsAccessKey,
secretKey: _awsSecretKey,
),
);
print(rekognition.toString());
final imageBytes = await imageFile.readAsBytes();
final response = await rekognition.compareFaces(
sourceImage: aws.Image(bytes: imageBytes),
targetImage: aws.Image(bytes: imageBytes),
);
//String detectedText = response.sourceImageFace?.map((detection) => detection.detectedText).join("\n") ?? "Nenhum texto detectado";
//print(detectedText);
setState(() {
//_result = detectedText;
});
} catch (e) {
setState(() {
//_result = "Erro ao analisar imagem: $e";
});
}
}
@override
void initState() {
super.initState();
_cameraController = CameraController(widget.cameraDescriptions![0], ResolutionPreset.high);
_initControllerFuture = _cameraController.initialize();
}
@override
void dispose() {
_cameraController.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: FutureBuilder(
future: _initControllerFuture,
builder: (context, snapshot) {
if (snapshot.connectionState == ConnectionState.done) {
final scale = 1 / (_cameraController.value.aspectRatio * MediaQuery.of(context).size.aspectRatio);
return Transform.scale(
scale: scale,
alignment: Alignment.topCenter,
child: Stack(
children: [
CameraPreview(
_cameraController,
child: Container(
padding: EdgeInsets.all(20.0),
child: Row(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.spaceBetween,
crossAxisAlignment: CrossAxisAlignment.end,
children: [
Expanded(
child: InkWell(
borderRadius: BorderRadius.all(Radius.circular(50.0)),
onTap: () async {
try {
// Ensure that the camera is initialized.
await _initControllerFuture;
// Attempt to take a picture and get the file `image`
// where it was saved.
XFile image = await _cameraController.takePicture();
if (image.path != null) {
setState(() {
//_image = File(image.path);
});
await _analyzeImage(File(image.path));
print(File(image.path).toString());
}
Navigator.of(context).pop();
} catch (e) {
// If an error occurs, log the error to the console.
print(e);
}
},
child: Container(
padding: EdgeInsets.all(4.0),
child: Icon(Icons.camera_alt, color: Colors.white, size: 35.0),
),
),
),
Expanded(
child: InkWell(
borderRadius: BorderRadius.all(Radius.circular(50.0)),
onTap: () {
if (!_toggleCamera) {
onCameraSelected(widget.cameraDescriptions![0]);
setState(() {
_toggleCamera = true;
});
} else {
onCameraSelected(widget.cameraDescriptions![1]);
setState(() {
_toggleCamera = false;
});
}
},
child: Container(
padding: EdgeInsets.all(4.0),
child: Icon(Icons.flip_camera_android, color: Colors.white, size: 35.0),
),
),
),
],
),
),
),
IgnorePointer(
child: CustomPaint(
painter: CirclePainter(),
child: Container(),
),
),
],
),
);
} else {
// Otherwise, display a loading indicator.
return const Center(child: CircularProgressIndicator());
}
},
),
);
}
void onCameraSelected(CameraDescription cameraDescription) async {
_cameraController = CameraController(cameraDescription, ResolutionPreset.high);
_cameraController.addListener(() {
if (mounted) setState(() {});
if (_cameraController.value.hasError) {
showMessage('Camera Error: ${_cameraController.value.errorDescription}');
}
});
try {
_initControllerFuture = _cameraController.initialize();
} on CameraException catch (e) {
showMessage('Camera Error: $e');
}
if (mounted) setState(() {});
}
void showMessage(String s) {
QuickAlert.show(
disableBackBtn: false,
showConfirmBtn: false,
context: context,
type: QuickAlertType.error,
title: 'Error',
text: s.toString(),
);
}
}
class RectanglePainter extends CustomPainter {
double? topMargin;
Size? Function(Size)? size;
// style
double strokeWidth = 2.0;
Color strokeColor = Colors.white;
Color? overlayColor;
Radius? borderRadius;
RectanglePainter({
this.topMargin,
this.strokeWidth = 2.0,
this.strokeColor = Colors.white,
this.overlayColor,
this.borderRadius,
});
@override
void paint(Canvas canvas, Size size) {
final topMargin = this.topMargin ?? (size.height * 0.3);
final width = this.size?.call(size)?.width ?? size.width * 0.8;
final height = this.size?.call(size)?.height ?? ((size.width * 0.8) / 1.5);
final borderRadius = this.borderRadius ?? const Radius.circular(10);
// Step 1: Draw the overlay with transparent rectangle
final overlayPath = Path()
..addRRect(
RRect.fromRectAndRadius(
Rect.fromCenter(
center: Offset(size.width / 2, topMargin),
width: width,
height: height,
),
borderRadius,
),
)
..addRect(Rect.fromLTWH(0.0, 0.0, size.width, size.height))
..fillType = PathFillType.evenOdd;
final overlayColor = this.overlayColor ?? Colors.black.withOpacity(0.7);
final overlayPaint = Paint()
..style = PaintingStyle.fill
..color = overlayColor; // semi-transparent black overlay
canvas.drawPath(overlayPath, overlayPaint);
// Step 2: Draw the white stroke around the circle
final strokePath = Path()
..addRRect(
RRect.fromRectAndRadius(
Rect.fromCenter(
center: Offset(size.width / 2, topMargin),
width: width,
height: height,
),
borderRadius,
),
);
final strokePaint = Paint()
..style = PaintingStyle.stroke
..strokeWidth = strokeWidth
..color = strokeColor; // white stroke
canvas.drawPath(strokePath, strokePaint);
}
@override
bool shouldRepaint(covariant CustomPainter oldDelegate) => true;
}
class CirclePainter extends CustomPainter {
double? topMargin;
double? Function(Size size)? circleRadius;
double progress = 0.0;
// style
double strokeWidth = 2.0;
Color strokeColor = Colors.white;
Color? overlayColor;
Color progressColor = Colors.green;
CirclePainter({
this.topMargin,
this.circleRadius,
this.progress = 0.0,
this.strokeWidth = 2.0,
this.strokeColor = Colors.white,
this.overlayColor,
this.progressColor = Colors.green,
});
@override
void paint(Canvas canvas, Size size) {
final circleRadius = this.circleRadius?.call(size) ?? ((size.width / 1.25) / 2);
final topMargin = this.topMargin ?? (size.height * 0.35);
// Step 1: Draw the overlay with transparent circle
final overlayPath = Path()
..addOval(
Rect.fromCenter(
center: Offset(
size.width / 2, // x-axis center
topMargin, // y-axis center with margin
),
width: size.width / 2,
height: size.height / 3)
/*Rect.fromCircle(
center: Offset(
size.width / 2, // x-axis center
topMargin, // y-axis center with margin
),
radius: circleRadius,
)*/,
)
..addRect(Rect.fromLTWH(0, 0, size.width, size.height))
..fillType = PathFillType.evenOdd;
final overlayColor = this.overlayColor ?? Colors.black.withOpacity(0.7);
final overlayPaint = Paint()
..style = PaintingStyle.fill
..color = overlayColor;
canvas.drawPath(overlayPath, overlayPaint);
// Step 2: Draw the white stroke around the circle
final strokePath = Path()
..addOval( Rect.fromCenter(
center: Offset(
size.width / 2, // x-axis center
topMargin, // y-axis center with margin
),
width: size.width / 2,
height: size.height / 3)/*Rect.fromCircle(
center: Offset(
size.width / 2, // x-axis center
topMargin, // y-axis center with margin
),
radius: circleRadius,
)*/);
final strokePaint = Paint()
..style = PaintingStyle.stroke
..strokeWidth = strokeWidth
..color = strokeColor; // white stroke
canvas.drawPath(strokePath, strokePaint);
if (progress != 0.0) {
assert(this.progress >= 0.0 && this.progress <= 1.0);
// Step 3: Draw the progress arc (quarter circle)
final progressRect = Rect.fromCircle(
center: Offset(
size.width / 2, // x-axis center
topMargin, // y-axis center with margin
),
radius: circleRadius,
);
final strokeProgressPaint = Paint()
..style = PaintingStyle.stroke
..strokeWidth = strokeWidth
..color = progressColor;
final progress = this.progress * 4; // 4 means full of circle, 2 means half of circle, 1 means quarter of circle
// Draw only a portion of the circle, progress defines how much
canvas.drawArc(
progressRect,
-90 * 3.1416 / 180, // Start angle (-90° = top of the circle)
progress * (3.14 / 2), // Sweep angle based on progress (quarter of circle = π/2 radians)
false,
strokeProgressPaint,
);
}
}
@override
bool shouldRepaint(covariant CustomPainter oldDelegate) => true;
}
class OverlayPainter extends CustomPainter {
final double screenWidth;
final double screenHeight;
OverlayPainter({required this.screenWidth, required this.screenHeight});
@override
void paint(Canvas canvas, Size size) {
final radius = screenWidth * 0.45;
final strokeWidth = 2.0;
final circlePath = Path()
..addOval(Rect.fromCircle(
center: Offset(screenWidth / 2, screenHeight / 2.5),
radius: radius,
));
final outerPath = Path()
..addRect(Rect.fromLTWH(0, 0, screenWidth, screenHeight));
final overlayPath =
Path.combine(PathOperation.difference, outerPath, circlePath);
final paint = Paint()
..color = Colors.black.withOpacity(0.7)
..style = PaintingStyle.fill;
final borderPaint = Paint()
..color = Colors.white
..style = PaintingStyle.stroke
..strokeWidth = strokeWidth;
canvas.drawPath(overlayPath, paint);
canvas.drawCircle(
Offset(screenWidth / 2, screenHeight / 2.5),
radius,
borderPaint,
);
}
@override
bool shouldRepaint(CustomPainter oldDelegate) {
return false;
}
}
