Android Cricket Live Score App with Ball-by-Ball Updates and Match Alerts

Cricket fans follow a match one ball at a time, but most free score apps bury the score behind ads, refresh slowly, or show only the total without explaining what just happened. A fan who misses the video feed wants to know who is batting, how many runs are needed, what the last ball did, and whether a wicket has fallen — within seconds, not minutes later. The Android Cricket Live Score App with Ball-by-Ball Updates and Match Alerts is built around that gap: it presents the live score, the over-by-over story of the match, the full scorecard and instant alerts for wickets, fifties and results in a single clean app. The demo ships with a seeded India-versus-Australia T20 chase that works offline, and the production build connects to a licensed cricket-data API for real live scores. For students, it demonstrates a real mobile product: a working score engine, a commentary feed, an alert rules engine and a Material interface.

The app works as a pipeline from a delivery to a notification. A match engine holds the state of the game — runs, wickets, balls bowled, the two batsmen at the crease and the current bowler — and every delivery updates that state once. The score screen recomputes the totals, the run rate and the required rate from the same state, so every screen agrees. The same delivery is then written into the commentary feed as one over-labelled entry describing what happened, and the alert engine checks the new state against its rules: a wicket, a batsman reaching fifty or a hundred, or the match ending. When a rule fires, the app queues a push notification and adds the event to the alert inbox. The scorecard aggregates the same deliveries into batting and bowling figures. In the demo the deliveries come from a seeded simulation; in production they arrive from a licensed cricket-data API — only the data source changes.

1. The app loads the match list — seeded demo matches offline, or live fixtures from the configured cricket-data API in production.
2. The match engine holds one state object: runs, wickets, balls bowled, the two batsmen, the bowler and the target.
3. Each delivery updates that state once — runs added, wicket recorded, strike rotated on odd runs, new batsman sent in on a dismissal.
4. The score screen recomputes the total, overs, run rate and required rate from the same state and redraws; the demo build does this refresh in 0.5–0.8 ms (measured in the demo build, local Chromium).
5. The commentary engine appends one over-labelled entry for the delivery, describing the outcome in plain language.
6. The alert engine checks the new state against its rules — wicket, fifty, hundred, result — and queues a push notification plus an inbox entry when a rule fires.
7. The scorecard aggregates every delivery into the batting card and bowling figures, so the post-match numbers always match the live score.

Tech stack:

• Kotlin
• Jetpack Compose · Material 3
• Android Studio
• Room (local match cache)
• WorkManager (alert scheduling)
• Retrofit · licensed cricket-data API
• Firebase Cloud Messaging (push alerts)
• Git

The app is built around four capabilities that a cricket fan actually uses during a match. The live score screen shows the total, the overs, the run rate and the required rate, with the two batsmen and the current bowler always visible. The ball-by-ball commentary feed turns each delivery into one plain-language entry — boundaries, wickets and quiet overs alike — so a fan who cannot watch still follows the story of the game. Match alerts push a notification the moment a wicket falls, a batsman reaches fifty or a hundred, or the result is decided, with a separate on-off toggle for each alert type. The full scorecard carries the batting card with dismissal details and the bowling figures for after the match. Around those four, the app adds a seeded match simulator for offline demonstration, a favourites list, and a series view — everything a student needs to show a complete mobile product.

• [Live score screen] Runs, wickets, overs, current run rate and required run rate recomputed after every delivery, with the two batsmen, their scores and the current bowler always on screen.
• [Ball-by-ball commentary feed] One over-labelled plain-language entry per delivery — boundaries, wickets, maidens and quiet overs — so the story of the match is readable without video.
• [Match alerts] Push alerts for wickets, fifties, hundreds and the match result, with a separate on-off toggle for each alert type in the settings screen.
• [Full scorecard] Complete batting card with dismissal details and runs and balls per batsman, plus bowling figures (overs, runs, wickets) for every bowler.
• [Seeded match simulator] A built-in simulation engine plays a realistic T20 chase ball by ball, so the whole app — score, commentary, alerts and scorecard — can be demonstrated offline with no API key.
• [Favourites and series view] Follow a team to get its matches first, and browse the series schedule and results from the same app.
• [Clean Material interface] Four-tab navigation (Live, Commentary, Scorecard, Alerts) with a dark-green match theme, readable at a glance during a live game.

• Complete Android source code (Kotlin + Jetpack Compose)
• Working demo build with a seeded match and ball-by-ball simulation
• Ball-by-ball commentary engine and alert rules engine
• Scorecard, favourites and series screens
• Setup guide including cricket-data API key configuration steps
• Project report PDF (background, architecture, match engine, API integration, testing)
• PPT presentation for final review
• Viva Q&A preparation document (Android lifecycle, state management, API integration, push notifications)