Food Delivery App Project

The Food Delivery App Project is a native Android food-ordering application built with Kotlin that recreates the complete customer journey of a commercial delivery platform: discovering restaurants, browsing menus, building a cart, paying, and watching the order arrive on a live map. Students usually learn Android through isolated tutorials — one screen for lists, another for databases — and never connect authentication, a cloud database, payments and push notifications into one working system. This project closes that gap by wiring Firebase Authentication, Cloud Firestore and Firebase Cloud Messaging into a single Kotlin codebase, with the Google Maps SDK rendering the delivery-tracking screen. Ordering food is a workflow every student understands, which makes the architecture easy to defend in a viva: a Firestore restaurant document becomes a card on screen, a cart becomes an order document, and a Cloud Messaging push advances the tracking timeline. The result is a portfolio-grade app demonstrating real client-server thinking on Android, not another offline demo.

A customer opens the Food Delivery App Project, signs in once with Firebase Authentication, and lands on restaurant discovery backed by a Firestore collection: each restaurant document carries its name, cuisine, rating, ETA and menu sub-collection, and the app renders cards straight from those documents. Tapping a restaurant opens its menu, where stepper taps mutate a single cart state object that feeds the badge, the cart screen and checkout simultaneously. Checkout writes one order document to Firestore containing the items, address, payment mode and a "placed" status. From there the flow is push-driven: Cloud Functions update the order status through preparing, on the way, arriving and delivered, and each change arrives on the phone as a Firebase Cloud Messaging push that advances the tracking timeline and moves the rider marker on the Google Maps SDK view. Ratings and history are local-first reads of the user's own order documents.

1. The user signs in with a phone number through Firebase Authentication; the auth token secures every Firestore read and write.
2. The home screen queries the restaurants collection in Firestore and renders cards with live search and cuisine filters applied on-device.
3. Opening a restaurant loads its menu sub-collection; ADD/stepper taps update one shared cart object that keeps the badge, cart screen and checkout in sync.
4. Checkout collects the delivery address and payment choice, then writes a single order document (items, totals, address, payment mode, status "placed") to Firestore.
5. Cloud Functions advance the order status through preparing, on the way, arriving and delivered as the kitchen and rider act.
6. Each status change is pushed to the phone via Firebase Cloud Messaging; the app advances the timeline, moves the rider marker on the Google Maps SDK view and refreshes the ETA without polling.

Tech stack:

• Kotlin, Android Studio
• Firebase Authentication (phone sign-in)
• Cloud Firestore (restaurants, menus, orders)
• Firebase Cloud Messaging (order-status pushes)
• Google Maps SDK for Android (tracking screen)
• Jetpack ViewModel · LiveData (UI state)
• Glide (restaurant and dish image loading)
• Material Design 3 components

The Food Delivery App Project ships four capabilities that carry the whole demo: restaurant discovery with live search and one-tap cuisine filters across 6 restaurants; menu browsing with veg/non-veg markers, honest pricing and quantity steppers on 24 dishes; a cart and checkout flow that breaks down subtotal, delivery fee and GST and accepts UPI, card or cash on delivery; and live order tracking with a five-stage timeline, a rider marker on the route and an ETA card. Around these sit Firebase Authentication login, an order-history screen with star ratings, and offer banners on every restaurant card. Every screen reads from one shared state design, so the cart badge, the cart screen and the checkout total can never disagree with each other. The demo on this page runs the same flow end to end, so the listing shows real working behavior rather than mockups.

• [Restaurant discovery] Search across restaurant names and cuisines with one-tap cuisine filters; each card shows the rating, delivery ETA, cost for two and an offer banner.
• [Menu browsing] Full per-restaurant menus with veg/non-veg markers, item photos, descriptions and prices; ADD buttons turn into quantity steppers in place.
• [Cart with live bill breakdown] Quantities, subtotal, delivery fee (Rs.25, free above Rs.499) and 5% GST recompute on every change from a single state object.
• [Checkout with UPI, card and cash on delivery] Saved delivery address form with three payment methods; placing the order issues an order ID and clears the cart.
• [Live order tracking] Five-stage timeline (placed, preparing, on the way, arriving, delivered) with a rider marker moving along the route and an ETA card showing the delivery partner.
• [Order history and ratings] Past orders persist on the device with their items, totals and payment mode; delivered orders can be rated with star feedback.
• [Firebase Authentication login] Phone-number sign-in secures the account, so carts, addresses and order history follow the user across devices.
  Optional on request (not in the base build): a restaurant-owner panel for managing menus and order status, a delivery-rider app with GPS, and production payment-gateway onboarding.

• Complete Kotlin source code for the customer app (Android Studio project)
• Firebase project setup guide (Authentication, Firestore rules, Cloud Messaging, Cloud Functions)
• Firestore data model and security-rules documentation
• Interactive working demo of the customer flow for evaluation
• Project report PDF (background, architecture, methodology, screens)
• PPT presentation for the final review
• Viva Q&A preparation document (Firebase, Android components, push vs polling, Maps SDK)
• Buildable debug APK from the delivered source