Flutter

Introduction to Dart and its role in Flutter

Installing Dart SDK & essential development tools

Core syntax: variables, data types, constants

Control structures: if–else, switch, loops

Working with functions, parameters & returns

Collections overview: Lists, Sets, Maps

Setting up the Flutter SDK & creating your first app

Running apps on emulator & real device

Understanding widget architecture & widget tree

Difference between StatelessWidget & StatefulWidget

Core layout widgets: Row, Column, Container

Spacing & alignment using margin, padding, MainAxisAlignment, etc.

Text, Icon & Image widgets in detail

How the build() method works internally

Creating clean, reusable custom widgets

Understanding state & UI rebuilds

Managing UI states with setState() effectively

Performance and rebuild optimization basics

Navigation fundamentals: push/pop

Passing arguments between screens

Named routes & route management

Multi-screen navigation using BottomNavigationBar & TabBar

Handling back navigation & lifecycle behavior

TextField & TextFormField usage

Form widget structure & validation logic

Handling focus, keyboard actions & controllers

Real-time input validation & formatting

Displaying error messages & custom warnings

Designing beautiful input fields with InputDecoration

Making REST API requests using the http package

Parsing JSON to Dart objects with models

Using async, await & Futures in real apps

Handling errors in API calls

Loading indicators, empty states & error UI

Displaying fetched data using ListView

Basics of pagination & infinite scrolling

SharedPreferences for key-value data

SQLite & sqflite package setup

Insert, Update, Read, Delete operations

When to use SharedPreferences vs SQLite

Using FutureBuilder for stored data

Database versioning & migrations

Clean architecture for local persistence

Animation fundamentals: Tween, AnimationController

Implicit animations: AnimatedContainer, AnimatedOpacity

Explicit animations: AnimatedBuilder

Handling gestures with GestureDetector

Building complex UI using custom widgets

Slivers: SliverAppBar, SliverList & scroll effects

Hero transitions between screens

Why Provider? Understanding benefits

ChangeNotifier & ChangeNotifierProvider

Using Consumer, context.watch() & context.read()

Managing business logic separately

Multi-provider setup & proxy providers

Debugging & best practices for scalable apps

What is Bloc and why use it?

Understanding Cubit vs Bloc

Streams & reactive architecture

Creating Blocs, events & states

Using BlocBuilder, BlocConsumer & BlocListener

Handling complex asynchronous state transitions

Debugging Bloc flow with logs

Writing unit tests for Dart functions

Widget testing for UI components

Integration testing for end-to-end scenarios

Structuring effective test cases

Using Flutter DevTools for debugging

Performance profiling & frame rendering checks

Logging, error capturing & monitoring

Building custom themes & color schemes

Supporting light & dark themes dynamically

Using MediaQuery & LayoutBuilder for responsiveness

Tablet-friendly & adaptive layout creation

Fonts, typography & brand consistency

Accessibility: labels, semantics, screen reader support

Animated theme switching

Setting up Firebase & FlutterFire

Email/password authentication flow

Registration, login, forgot password modules

Firestore structure & best data modeling

Real-time updates using streams

Firestore CRUD operations

Security rules & session management

FCM fundamentals & notification types

Configuring Android & iOS for push notifications

Handling foreground & background notifications

Custom notification UI & redirection

Managing device tokens & subscriptions

Sending notifications using Console & Cloud Functions

Testing, debugging & scaling notifications

Introduction to serverless backend

Setting up Cloud Functions locally

Writing secure backend logic

Firestore event triggers (create, update, delete)

Data validation & sanitization

Background tasks & automated workflows

Monitoring logs & performance

Understanding background execution limits

Using Workmanager plugin for Android

Scheduling periodic background tasks

Syncing remote data in the background

Handling background results & failures

Platform differences: iOS vs Android

Testing & optimizing background tasks

Firebase Analytics setup & event tracking

Custom event creation for user behavior

Crashlytics setup for crash reporting

Remote Config for live app updates

Performance monitoring overview

Improving performance using real-time data

Shared element transitions using Hero

Staggered animations for multi-step motion

Tween, CurvedAnimation & chained sequences

Custom animations using AnimatedBuilder

Gesture-driven animations

Performance optimization for animation-heavy screens

GestureDetector & Listener widget usage

Handling tap, double tap, long press

Drag & drop interactions

Pinch-to-zoom, rotate gestures

Custom gesture recognizers

Working with gesture arenas

Combining gestures with animation logic

Using Flutter DevTools for profiling

Reducing unnecessary widget rebuilds

Effective use of const & keys

Minimizing overdraw & expensive layouts

Image optimization & asset management

Memory leak detection techniques

Improving scroll performance & smoothness

Using Flex, Expanded & LayoutBuilder for responsiveness

Building layouts that adapt to different screen sizes

Multi-orientation support

Accessibility best practices & screen-reader compatibility

Keyboard navigation support

Testing accessibility across devices

Code signing for Android & iOS

Versioning, build numbers & environment configs

Creating APK, AAB & IPA builds

App bundle optimization & obfuscation

Testing release builds on devices

Preparing release notes & documentation

Creating developer accounts

Store listing creation & optimization

Uploading & reviewing app builds

Managing pricing, distribution & regional support

Publishing updates & tracking app performance

Monitoring crash reports & user feedback

Understanding CI/CD & why it's important

GitHub Actions setup for automated builds

Using Codemagic / Bitrise for release pipelines

Automated testing & code analysis

Push builds to testers automatically

Securing API keys & environment variables

Planning, wireframing & requirement analysis

Choosing architecture & state management

UI/UX design implementation

Backend/API integration

Testing, debugging & optimization

Deployment & publishing

Final presentation & code review