FatakSeRide is a driver-focused ride-request filtering and assistance application for Android. Its tagline is "Ride Faster. Work Smarter." The product is not a generic taxi app and not a mockup: it is a real, production-quality Android application that runs alongside the driver's ride-hailing apps (Uber, Ola, Rapido, Porter), detects genuine active ride/order requests through legitimate Android accessibility mechanisms, evaluates them locally against the driver's configured filters, and assists with the correct platform-specific action.
The audience is the working ride-hailing driver in India who operates one-handed, often in sunlight, with a very short decision window per request. The product's emotional register is instrument-grade trust: calm under pressure, zero tolerance for ambiguity, and a hard rule that when the system is uncertain it does nothing.
The secondary audience is the Developer / QA Engineer who validates the detection-to-action pipeline, filter boundaries, and platform adapters through Test Mode, the Filter Tester, and Developer Diagnostics.
FatakSeRide is delivered as a Flutter/Dart user interface over a native Android Kotlin core. The Flutter layer owns all driver-facing screens, configuration, history, analytics, and diagnostics presentation. The Kotlin layer owns the performance-critical pipeline: the AccessibilityService, event processing, platform adapters, ride parsing, the local filter engine, the decision engine, the action engine, and post-action verification. The two layers communicate through Flutter Platform Channels or Pigeon.
The pipeline is strictly layered:
Flutter UI
↓
Platform Channel
↓
Native Kotlin
↓
AccessibilityService
↓
Event Processor
↓
Platform Adapter
↓
Ride Parser
↓
Filter Engine
↓
Decision Engine
↓
Action Engine
↓
Verification
Processing is event-driven. The service reacts to AccessibilityEvent and inspects the accessibility tree via getRootInActiveWindow() and AccessibilityNodeInfo. It does not continuously screenshot, OCR, or poll the screen every few milliseconds. Debouncing and deduplication prevent repeated processing of the same request.
Four independent platform adapters exist — UberAdapter, OlaAdapter, RapidoAdapter, PorterAdapter — and no single universal implementation serves every platform. The active Android package is identified and routed to the correct adapter; unknown packages are ignored, and if the active package changes while an action is pending, the action is cancelled.
All filtering and decision-making happen locally. Ride information is never sent to a server before a filter decision is made. Actual latency is measured and reported; no guaranteed one-second performance is claimed.
The driver-facing surface includes Home, Live Rides, Filters, History, Analytics, Settings, Permissions, Permission Center, Subscription, Account, Wallet, Test Mode, Developer Mode, Filter Tester, and Developer Diagnostics, preceded by an anonymous Landing entry and identity access through Login and Sign Up.
Narrow exclusions. FatakSeRide does not collect passwords, OTPs, unrelated messages, or unnecessary personal information. It does not trigger on home screens, profiles, settings, maps, navigation, completed trips, login, OTP, messages, or unrelated popups. It does not randomly tap, swipe, or guess missing ride information. It does not hardcode screen coordinates as the primary interaction method. It does not leave core functionality as fake APIs, simulated acceptance, fake latency, hardcoded success, or placeholder methods.
FatakSeRide is a first-party Android application with its own Flutter UI and its own native Kotlin accessibility core. The driver installs it, grants the Android permissions it actually requires, signs in, selects a supported platform, configures filters, and turns Assist ON. From that point the application observes the target ride app through the Android accessibility framework and acts only when a request genuinely matches the driver's filters and the correct action can be confidently identified.
Identity is application-owned. A driver independently begins use through self-service enrollment and returns through verification; a provisioned Developer / QA Engineer reaches role-restricted diagnostics and test destinations through the same access boundary. The Landing surface is anonymous and explains the product before any protected work begins. Protected destinations — Home, Live Rides, Filters, History, Analytics, Settings, Permissions, Permission Center, Subscription, Account, Wallet, Test Mode, Developer Mode, Filter Tester, and Developer Diagnostics — require an established identity.
The current delivery horizon covers everything described in this document. No future-horizon capabilities are asserted here beyond the current product.
The supplied reference screenshots are behavioral and visual references for specific driver-facing surfaces. They are not a content source for factual entities, collections, or records, and no verified factual dataset is supplied for reproduction. Accordingly, no source content inventory is rendered.
Each requirement below is a distinct story point. Provenance is marked explicit, basic_default, or required_inference.
FR-01 — Product identity. As a Ride-Hailing Driver, I should see the application identified as FATAKSERIDE with the tagline "Ride Faster. Work Smarter." so that I know I am using the correct product. (explicit)
FR-02 — Driver-focused assistance purpose. As a Ride-Hailing Driver, I should use an application whose purpose is ride-request filtering and assistance — not a generic taxi app — so that my workflow is built around detecting, evaluating, and acting on ride requests. (explicit)
FR-03 — Flutter UI over native Kotlin core. As a Ride-Hailing Driver, I should interact with a Flutter/Dart user interface backed by native Android Kotlin for performance-critical functionality so that the interface is responsive while the detection-to-action pipeline stays fast. (explicit)
FR-04 — Layered architecture. As a Developer / QA Engineer, I should have the system built on the layered architecture Flutter UI → Platform Channel → Native Kotlin → AccessibilityService → Event Processor → Platform Adapter → Ride Parser → Filter Engine → Decision Engine → Action Engine → Verification so that each stage has a single responsibility and can be validated independently. (explicit)
FR-05 — Low latency with measured results. As a Ride-Hailing Driver, I should have the complete detection-to-action pipeline optimized for low latency, with critical processing kept in Kotlin and no ride information sent to a server before a filter decision, so that decisions arrive within the request window. (explicit)
FR-06 — Event-driven processing. As a Ride-Hailing Driver, I should have the application process only relevant accessibility events with debouncing and deduplication, and never continuously screenshot, OCR, or poll the screen every few milliseconds, so that the application is efficient and does not waste battery. (explicit)
AccessibilityEvent. Observable result: only relevant events are processed; duplicate events within the deduplication window are not reprocessed. Failure/recovery: an irrelevant event is discarded without side effects. Continuation: the next relevant event is processed normally.FR-07 — Separate platform adapters. As a Developer / QA Engineer, I should have separate UberAdapter, OlaAdapter, RapidoAdapter, and PorterAdapter implementations, never one universal implementation for every platform, so that each platform's request UI is handled on its own terms. (explicit)
FR-08 — Package detection and routing. As a Ride-Hailing Driver, I should have the active Android package identified and routed to the correct adapter, with unknown packages ignored, so that the application only acts inside supported ride apps. (explicit)
FR-09 — Cancel on package change. As a Ride-Hailing Driver, I should have a pending action cancelled if the active package changes while that action is pending, so that an action is never delivered to the wrong application. (explicit)
FR-10 — Genuine request detection only. As a Ride-Hailing Driver, I should have the application detect only genuine active ride/order requests and never trigger on home screens, profiles, settings, maps, navigation, completed trips, login, OTP, messages, or unrelated popups, so that the application never acts outside a real request. (explicit)
FR-11 — Accessibility tree inspection. As a Developer / QA Engineer, I should have the system use getRootInActiveWindow() and AccessibilityNodeInfo to inspect text, contentDescription, resourceName, className, clickable state, enabled state, visibility, bounds, and available actions, so that request detection and action targeting are grounded in the real UI. (explicit)
FR-12 — Framework independence. As a Developer / QA Engineer, I should have the application interact through legitimate Android accessibility/UI mechanisms without assuming the target app is Flutter, so that it works against native Android, Flutter, React Native, custom-rendered, or other target implementations. (explicit)

Ride Faster. Work Smarter.
Driver assistance workflow
Choose the ride platform you are driving on — Uber, Ola, Rapido or Porter. FatakSeRide routes the active package to that platform’s own adapter.
Set minimum fare, pickup distance, trip distance, fare per kilometre, ride type and request type. Every enabled filter is evaluated with AND logic.
Keep working in the ride app as you normally would. FatakSeRide listens for accessibility events in the background instead of screenshotting or polling the screen.
Only genuine active ride and order requests are read, through the accessibility tree — text, labels, resource names, clickable state and bounds. Home screens, profiles and settings are ignored.
The filter decision happens on the device, before any network call. If a required value is missing or the correct action cannot be identified with confidence, FatakSeRide does nothing.
In short
FatakSeRide is a driver-focused ride-request filtering and assistance application — not a generic taxi app.
Supported ride platforms
FatakSeRide works across the four ride platforms you already drive for. Uber, Ola, Rapido and Porter are each handled by their own platform adapter — no universal implementation, no guessing at the request UI.
Evaluation happens locally on the device. Fares, distances, fare per kilometre, ride type and request type are compared against your filters inside FatakSeRide, not in the cloud.
No ride information is sent to a server before a filter decision is made. The filter decision is reached first. The pipeline keeps its critical processing close to the event that produced it.
When the system is uncertain, it does nothing rather than guessing. A missing required value, an unreadable node, or an unclear action control produces no action — never an assumed one.
FatakSeRide never randomly taps, swipes, or guesses missing ride information.

Ride Faster. Work Smarter.
Driver assistance workflow
Choose the ride platform you are driving on — Uber, Ola, Rapido or Porter. FatakSeRide routes the active package to that platform’s own adapter.
Set minimum fare, pickup distance, trip distance, fare per kilometre, ride type and request type. Every enabled filter is evaluated with AND logic.
Keep working in the ride app as you normally would. FatakSeRide listens for accessibility events in the background instead of screenshotting or polling the screen.
Only genuine active ride and order requests are read, through the accessibility tree — text, labels, resource names, clickable state and bounds. Home screens, profiles and settings are ignored.
The filter decision happens on the device, before any network call. If a required value is missing or the correct action cannot be identified with confidence, FatakSeRide does nothing.
In short
FatakSeRide is a driver-focused ride-request filtering and assistance application — not a generic taxi app.
Supported ride platforms
FatakSeRide works across the four ride platforms you already drive for. Uber, Ola, Rapido and Porter are each handled by their own platform adapter — no universal implementation, no guessing at the request UI.
Evaluation happens locally on the device. Fares, distances, fare per kilometre, ride type and request type are compared against your filters inside FatakSeRide, not in the cloud.
No ride information is sent to a server before a filter decision is made. The filter decision is reached first. The pipeline keeps its critical processing close to the event that produced it.
When the system is uncertain, it does nothing rather than guessing. A missing required value, an unreadable node, or an unclear action control produces no action — never an assumed one.
FatakSeRide never randomly taps, swipes, or guesses missing ride information.
No comments yet. Be the first!