Facial Recognition API Migration - Android Dev

@om26er

Hello, Phase 1, Let's share the source code so i can check all the existing implementations and discuss to implement your own python based Face Recognition feature. i am a native Android applications developer with over 8 years of experience developing Android mobile applications. I have completed more than 515 projects. I am confident that I will provide you with quality work and the best software services. Let's chat to proceed.

@gotucat

Hi, I reviewed the project and understand the main requirement: migrate the existing Java Android attendance app from Azure Face API to your self-hosted Python facial-recognition API, then add liveness integration without rebuilding the application. I can review the current Azure integration, camera flow, enrollment, recognition, and attendance logic before connecting the REST API through secure HTTP POST requests. Using Android, Mobile App Development, and API expertise, I’ll implement project_id isolation, multipart image uploads, JSON response handling, asynchronous networking, retries, timeouts, authentication, duplicate prevention, and clear liveness outcomes while preserving existing business logic. I’ll maintain responsive, clean, documented code and coordinate API contracts and performance testing for concurrent devices and spoof scenarios. Let’s discuss here now.

@a4logic

Hello, As an accomplished Android developer for over a decade, I have tackled and successfully triumphed over migration projects quite similar to yours. Having served numerous clients with their diverse mobile application needs, I've garnered extensive experience in using REST APIs, piloting python applications, and managing secure HTTPS POST requests; all of which are critical to the fundamental phase of your project. Thanks!

@CodeAnchors

Hello, I trust you are well. I have reviewed the project requirements for the Facial Recognition API Migration and Liveness Integration for your Android application. My expertise lies in Android Java development, with a strong background in API integration and mobile app development. For the first phase, I will meticulously review the existing Java code, identify Azure Face API integration points, and seamlessly integrate your new Python facial recognition API. I will ensure smooth enrollment, recognition, and attendance workflows, handling multiple projects and maintaining UI responsiveness. Additionally, I will focus on error handling, network testing, and removing Azure dependencies post-validation. In the second phase, I will integrate the chosen liveness solution, ensuring facial recognition only after successful liveness checks. I will collaborate with the backend developer on anti-spoofing measures, handle API responses, and optimize the attendance process without compromising speed. I am confident in delivering reliable results and long-term success for your project. Please find my portfolio for your reference: ⭐⭐ https://www.freelancer.com/u/CodeAnchors ⭐⭐ Could you kindly elaborate on your top priority or key business goal for this project? Best regards, Muhammad Anas Khan

@melikatfz

Hi there, Switching from the Azure Face API to a self-hosted solution poses challenges such as ensuring seamless integration and handling potential API discrepancies. With my extensive experience in Android development and API integrations, I can ensure a smooth transition and maintain the app's reliability and performance. Here are my questions to better understand your requirements: 1. Are there any specific error codes or exceptions currently handled in the Azure integration that need mapping in the new API? 2. Do you have any preferred libraries or existing standards for handling image compression and upload? Let's discuss your project now!

@cliftonc20

Hi, Your migration from Azure Face API to a self-hosted Python facial recognition backend requires precise integration with existing Android workflows, especially managing project-specific datasets and concurrency. The main technical risk is ensuring reliable asynchronous API communication and error handling on the Android side without degrading UI responsiveness. I've led the design and implementation of complex FastAPI backends and AI SaaS platforms like DocIntel AI, which involved orchestrating asynchronous pipelines and API reliability under load. Additionally, my work on Dent-Cloud involved scalable API integrations and secure token handling, relevant to your multi-project facial recognition environment. I typically design systems by separating ingestion, recognition, and response layers to isolate failures and scale independently. For your Android integration, I’d validate concurrency controls and error recovery early to prevent duplicate attendance and maintain smooth UI operation. For reliability, implementing idempotent request handling, retries with exponential backoff, and clear error propagation will reduce failures and improve user experience. I can start by reviewing your current API integration and outlining a robust Android-to-backend communication architecture. Thanks, Clifton

@crtvecode

The main challenge here is migrating from the Azure Face API to that new Python-based API while preserving the existing attendance logic and making sure smooth performance. And I’ll start by reviewing the current Android Java code to pinpoint where Azure is integrated and how the enrollment and recognition workflows operate, I’ll then modify the app to connect with your new Python REST API, making sure it handles multiple projects and processes API calls off the main thread to keep the UI responsive. I can go ahead and complete this work first so you can test it before any payment or award. You’ll only create a milestone once you’re satisfied with the results—this way, there’s no risk on your end. My rate for these project is 54 GBP, and I’m ready to start immediately. Rajavel Specializing in Android development and API integrations.

@godesignpk

Hi, I see you're migrating to a self-hosted facial recognition API. I can help integrate your new Python API into the existing Android app. First, I'll review the current Azure integration and identify changes needed for the new API. What specific challenges do you foresee with the current workflow? Best regards, Waqas & GoDesign Team

@poojatdsl

Hi, I can migrate your existing Android Java attendance app from Azure Face API to your self-hosted Python/FastAPI facial-recognition API without unnecessarily rebuilding the existing application. I’ll first audit the current Azure integration, camera/enrollment/recognition flow, networking library, and attendance logic. Then I’ll replace the Azure-specific calls with secure REST integration using Retrofit/OkHttp, multipart image uploads, project ID handling, JSON response validation, authentication tokens, asynchronous processing, retries/timeouts, and duplicate-scan protection. Each project’s facial dataset will remain isolated through the correct project ID. For Phase 2, I’ll integrate the agreed liveness/anti-spoofing workflow into the existing camera flow so recognition and attendance occur only after successful liveness validation, including handling failed challenges and photo/screen spoof testing. Relevant experience includes Android Java, Camera/CameraX, REST APIs, multipart uploads, JSON, Retrofit/OkHttp, background processing, authentication, image compression, API migrations, and production app debugging. You’ll receive a buildable Android project, documented source changes, tested recognition/enrollment/attendance flow, network/error handling, and liveness integration with backend coordination. Let’s connect to review the existing Android code and identify the Azure integration points first.

@mhdsarim01

Hi, I can audit the Java codebase, map every Azure Face API dependency, and migrate the enrollment/recognition flow to your Python/FastAPI API using Retrofit/OkHttp with async processing, secure tokens, image compression, retries, timeout handling and proper response validation. The project-ID separation is especially important here. I’ll ensure each request targets the correct facial dataset and prevent duplicate attendance caused by retries or repeated scans. I’ll also test concurrent usage against your 100 scans/minute target without blocking the UI. For Phase 2, I can integrate the liveness flow so recognition only proceeds after a successful anti-spoof check, while keeping the camera architecture reusable and avoiding a major rewrite. I’d first review the existing camera, Azure integration, attendance flow and networking layer, then provide a clear migration plan and effort estimate for both phases.

@sasaprogramer21

Hi, Aleksandar here, from Serbia, to help you. Migrating off Azure only stays safe if attendance can never be recorded from a stale or duplicate result — that's the failure mode that quietly corrupts real data. I noticed you want duplicate submissions prevented even under retries — that means the attendance write needs an idempotency check tied to the request/recognition ID, not just a UI flag, so I'd build that guard into the API call layer first. I'd review the existing Java codebase to map every Azure touchpoint, then replace it with a Retrofit-based integration to your Python API, handling per-project routing, background threading so calls never block the UI, and structured handling for each response case (no face, low quality, multiple faces, invalid project, etc). Given the two-phase scope, I'd treat Phase 1, migration and validation, as its own milestone, with Phase 2's liveness work scoped once the API contract with your Python developer is locked. Looking forward to working with you.

@shawanay

Hi, I can migrate your existing Android Java application from Azure Face API to the new self-hosted Python/FastAPI recognition service without rebuilding the current attendance workflow, including enrollment, recognition, project-specific dataset routing, multipart image uploads, response validation, retry/error handling, duplicate-scan protection, and Azure dependency removal after validation. The Phase 1 flow will be existing code review identify Azure integration points map current camera/enrollment/recognition/attendance logic integrate the new REST API validate project IDs and API responses test concurrent scanning/network failures remove Azure-specific credentials and dependencies. Let’s connect so I can first review the current Android codebase, networking layer, camera implementation, and Azure integration before defining the exact migration steps. Regards, Shawana

@jayantkumar314

Hi, I’ll begin by tracing the existing Azure Face API calls, camera/enrollment flow and attendance logic so the production app can be migrated without an unnecessary rebuild. I’ll replace the Azure-specific integration with the Python REST API, including multipart image uploads, project-specific IDs, response validation, asynchronous requests, retries and duplicate-attendance protection. The existing attendance workflow will remain intact while matched, unmatched, low-quality, multiple-face and server/network failure responses are handled cleanly in the Android app. Once Phase 1 is validated, I’ll integrate the agreed liveness flow before recognition and test photo/screen spoof rejection without making normal attendance unnecessarily slow. I’ll coordinate the request/response contract with the backend developer and deliver documented, buildable Android source after integration and testing.

@AndrewJSMAN

I've migrated Azure Face API integrations in Java Android apps before, so this is right in my wheelhouse. I'll review the existing code to map Azure calls to our Python API endpoints, then replace the Azure SDK with Retrofit/OkHttp calls to our FastAPI backend. For Phase 1, I'll handle image capture, multipart uploads, project ID routing, and response validation while ensuring thread-safe background processing. For Phase 2, I'll integrate liveness checks using CameraX for frame capture and coordinate with the Python team on anti-spoofing endpoints. I'll validate concurrent requests and error states before removing Azure dependencies. I can start immediately. Thanks, Andrii.

@jeanpatrickr8

Hello, I appreciate the opportunity to bid on your project involving the migration of your Android app to a self-hosted facial recognition API. I understand that you require a skilled Android Java developer to seamlessly replace the Azure Face API integration while ensuring the application maintains its existing functionality and performance. With over five years of experience in Android development and a strong background in integrating RESTful APIs, I am well-equipped to tackle this project. I have extensive knowledge of Java, Android Studio, and networking libraries like Retrofit and OkHttp, which are crucial for this integration. To successfully execute this project, I propose the following approach: - Conduct a thorough review of your existing Android Java source code to identify all Azure-related integrations. - Safely remove Azure-specific components and establish a robust connection with your new Python REST API for image submissions. - Implement comprehensive error handling and ensure smooth simultaneous usage across multiple devices. - Collaborate closely with your backend developer to finalize API request and response structures for optimal performance. I am eager to start this project and confident in my ability to deliver quality results on time. Please feel free to reach out if you would like to discuss further details or clarify any aspects of the project. Thank you for considering my proposal.

@arehman171

Hi there, I’m an Android developer with 5 years of experience in Java/Kotlin, Retrofit/OkHttp, REST APIs, multipart image uploads, camera integration, asynchronous processing, and modifying existing production applications. I can review the current Azure Face API integration, replace it with your Python REST API, handle project IDs, enrollment/recognition responses, retries, timeouts, duplicate attendance prevention, and keep the UI responsive. For Phase 2, I can integrate the selected liveness/anti-spoofing solution into the existing camera flow and ensure recognition/attendance only proceeds after a successful liveness check, including testing against photo and screen-based spoof attempts. I’ll first map the existing Azure, camera, networking, and attendance flow before making targeted changes rather than unnecessarily rebuilding the app. I can work closely with your Python developer to finalize the API contract and deliver a buildable, documented Android project. Question: Is the existing Android source code and the new Python API already available for an initial technical review?

@vijaydogra03

Hello, I understand this as a migration job, not a rebuild: move the existing Azure Face API integration to your self-hosted Python (InsightFace/ArcFace, FastAPI) backend while preserving the current attendance/business logic and app workflow as much as possible. For Phase 1, I'll start by reviewing the codebase to map every Azure touchpoint (enrollment, recognition, verification, attendance, image upload), then isolate and remove Azure-specific code. I'll build the new integration using Retrofit/OkHttp with multipart image upload, correct project_id handling for multi-project isolation, and full response handling (matched, no-face, low-quality, invalid project, server errors). All API calls will run off the main thread, with retry logic and duplicate-submission prevention so repeated scans don't double-record attendance. I'll coordinate with your backend developer to finalize request/response contracts before locking implementation. For Phase 2, I'll integrate the liveness workflow into the existing camera flow so recognition only triggers after a liveness pass, supporting either passive or active challenges once you've decided the approach, plus clear failure messaging and spoof-attempt testing. I have strong Android Java, CameraX, REST/JSON, and async networking experience, and I'm comfortable reviewing and modifying production codebases rather than rebuilding them. Ready to start with the code review whenever you'd like. Best regards, Vijay Kumar Dogra

@emilesd617

Hi, I am an Android Java developer with 8 years of rich experience in software development, with a strong background in mobile API integration, camera workflows, and biometric applications. I am familiar with Java, Android Studio, CameraX, Retrofit, OkHttp, REST APIs, multipart image uploads, JSON, asynchronous networking, image compression, authentication, FastAPI, OpenCV, InsightFace, ArcFace, ONNX, error handling, retries, and CI/CD. For your existing Android application, I can first audit and replace the Azure Face API integration with your project-isolated Python REST API while preserving the current attendance workflow, then integrate liveness and anti-spoofing into the existing camera flow once Phase 1 is validated. I'm an individual freelancer and can work on any time zone you want. Please contact me with the best time for you to have a quick chat. Thanks. Emile.

@ranjika08

The main challenge here is migrating a production Android Java attendance app away from Azure Face API without breaking the current enrollment, recognition, and attendance flow. In projects like this, the real work is identifying every Azure-dependent point, restructuring the request/response handling for your Python API, and making sure retries, timeouts, and repeated scans do not create false attendance entries. I’d approach it in phases so the recognition migration is validated first, then liveness is added on top of a stable camera flow. My background fits existing-app modification work where Java Android code, camera capture, multipart uploads, JSON parsing, and backend coordination all have to work together reliably. I’m also comfortable working with custom REST endpoints and adapting an app to project-based data isolation, which matters here since each dataset must remain separate. - Is the current face capture flow based on CameraX or the older camera API? - Are you expecting the awarded scope to include both phases within this budget, or should this cover Phase 1 first? - Does the backend already return confidence thresholds and error codes, or are those still being finalized?