Aplicativo de gratidão e bem-estar com 508+ arquivos Dart, 35+ telas, 86+ serviços. Clean Architecture com Riverpod, dual persistence (Hive + Firebase), IA integrada com Gemini, e sistema de monetização ética gamificado.
GratiDiem é um companheiro diário de gratidão — um aplicativo sofisticado que ajuda usuários a cultivar bem-estar através de práticas de gratidão, meditação guiada, desafios diários, e comunidade.
O app suporta 6 plataformas (Android, iOS, Web, macOS, Windows, Linux), 3 idiomas (PT, EN, ES), e é construído para escalar para milhões de usuários.
┌─────────────────────────────────────────────────────────────────────────┐
│ PRESENTATION LAYER (UI) │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌────────────┐ │
│ │ Home │ │ Meditation │ │ Circles │ │ Settings │ │
│ │ Screen │ │ Player │ │ (Tribes) │ │ Admin │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ └────────────┘ │
│ 35+ screens, 62+ widgets │
└─────────────────────────────────────────────┬───────────────────────────┘
│
┌─────────────────────────────────────────────▼───────────────────────────┐
│ STATE MANAGEMENT (Riverpod) │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ 31 Riverpod Providers (AsyncNotifier + StateNotifier patterns) │ │
│ │ auth_provider circle_provider meditation_provider ritual/... │ │
│ └──────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────┬───────────────────────────┘
│
┌─────────────────────────────────────────────▼───────────────────────────┐
│ SERVICE LAYER (Business Logic) │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ 86+ Services: Auth, Storage, Analytics, Monetization, Circle, │ │
│ │ Gratitude, Meditation, Notification, Achievements, AI, etc. │ │
│ └──────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────┬───────────────────────────┘
│
┌─────────────────────────────────────────────▼───────────────────────────┐
│ DATA LAYER (Dual Persistence) │
│ ┌──────────────────────────┐ ┌────────────────────────────────┐ │
│ │ Hive CE (Local) │ ←──→ │ Firebase Firestore (Cloud) │ │
│ │ 126 models + adapters │ │ Real-time sync + backup │ │
│ │ Local-first, offline │ │ Conflict resolution │ │
│ └──────────────────────────┘ └────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────┘278+ arquivos, Material Design 3, responsive design, ConsumerWidget/ConsumerStatefulWidget
Riverpod com AsyncNotifier/StateNotifier, stream subscriptions, real-time updates
Singleton services + Repository pattern, 113 arquivos com responsabilidades claras
Dual persistence: Hive CE (local-first) + Firebase Firestore (cloud sync)
Diário de gratidão com entradas diárias, categorias, tags, e busca full-text. Suporte a imagens e compartilhamento social.
Player de áudio com sessões de meditação (manhã, dia, ansiedade, noite, profunda). Just Audio + Audio Session para background playback.
Comunidades sociais com rituais em grupo, posts, desafios colaborativos, gamificação, e sync real-time via Firestore.
Desafios diários, streaks, sistema de níveis, árvore de progressão, achievements, e surprise rewards.
Ritual noturno guiado com meditação, reflexão, intenções para o próximo dia. Scheduling com notificações locais.
Módulo de saúde mental com jornada de adversidade, práticas terapêuticas, histórias inspiradoras, recursos de emergência.
Cápsulas do tempo para guardar memórias e gratidões a serem abertas no futuro.
Definição de valores pessoais, visualização de metas, reviews periódicos.
Assessments de bem-estar, gráficos de humor (fl_chart), calendário de atividades (table_calendar).
Motor de IA multi-backend com Google Gemini, Hugging Face, e modelos on-device (TensorFlow Lite).
class AIEngine {
factory AIEngine() => _instance;
static final AIEngine _instance = AIEngine._internal();
final Map<String, dynamic> _config = {
'ollama_url': 'http://localhost:11434',
'huggingface_key': 'hf_free',
'use_local_models': true,
'gemini_key': '',
'use_tensorflow': true,
};
// Backends disponíveis:
// 1. Google Gemini (cloud)
// 2. Hugging Face API (cloud)
// 3. Ollama (local server)
// 4. TensorFlow Lite (on-device)
/// Análise de sentimento com cache
Future<double> analyzeSentiment(String text) async {
if (_sentimentCache.containsKey(text)) {
return _sentimentCache[text]!;
}
// Tenta backends em ordem de preferência
final result = await _tryBackends(text);
_sentimentCache[text] = result;
return result;
}
/// Geração de respostas contextuais
Future<String> generateResponse({
required String prompt,
required AIResponseType type,
}) async {
// Templates específicos por tipo
final template = AIPromptTemplates.getTemplate(type);
return await _generate(template.format(prompt));
}
}Detecta emoções nas entradas de gratidão com cache para performance
Categoriza automaticamente entradas (família, trabalho, saúde, etc.)
Gera reflexões e sugestões baseadas no histórico do usuário
Features avançadas para usuários premium com Gemini Pro
Insights e tendências derivados das práticas de gratidão
Transformando anúncios em "momentos de gratidão" — monetização integrada ao conceito do app, criando experiência significativa ao invés de intrusiva.
Mensagens de gratidão personalizadas baseadas no contexto do usuário.
Sistema gamificado com tokens que podem ser ganhos e usados no app.
Controle dinâmico de toda a monetização sem deploy.
class GratitudeTriggersService {
/// Detecta o momento ideal para exibir apelo de gratidão
Future<GratitudeTrigger?> detectTrigger(BuildContext context) async {
final userState = await _getUserState();
// Verifica cooldown
if (await _isInCooldown()) return null;
// Detecta contexto emocional
final emotionalState = await _emotionalStateDetector.detect();
// Seleciona trigger baseado no contexto
return _selectBestTrigger(
userState: userState,
emotionalState: emotionalState,
recentActions: await _getRecentActions(),
);
}
/// Tipos de triggers contextuais
enum GratitudeTriggerType {
postRitual, // Após completar ritual
streakAchieved, // Conquista de streak
highEnergy, // Alta energia coletiva no círculo
firstExperience, // Primeira vez em feature
socialShare, // Momento de compartilhamento
achievementUnlocked,
}
}Arquitetura local-first com Hive CE para performance e offline, sincronizando automaticamente com Firebase Firestore.
// 126 models com TypeAdapters
@HiveType(typeId: HiveTypeIds.gratitudeEntry)
class GratitudeEntry extends HiveObject {
@HiveField(0)
late String id;
@HiveField(1)
late String content;
@HiveField(2)
late DateTime createdAt;
@HiveField(3)
List<String> tags = [];
@HiveField(4)
String? imageUrl;
@HiveField(5)
double? sentimentScore;
}
// hive_type_ids.dart - Registry centralizado
class HiveTypeIds {
static const int gratitudeEntry = 0;
static const int user = 1;
static const int challenge = 2;
// ... 197 entries
}197 TypeIDs registrados, código gerado via build_runner, adapter registry centralizado.
class SyncService {
/// Sync com conflict resolution
Future<void> syncToCloud() async {
final localChanges = await _getLocalChanges();
for (final change in localChanges) {
try {
final serverVersion = await _getServerVersion(change.id);
if (serverVersion == null) {
// Novo item - push direto
await _pushToServer(change);
} else if (change.updatedAt > serverVersion.updatedAt) {
// Local mais recente - push
await _pushToServer(change);
} else if (change.updatedAt < serverVersion.updatedAt) {
// Server mais recente - pull
await _pullFromServer(change.id);
} else {
// Conflito - merge strategy
await _resolveConflict(change, serverVersion);
}
} catch (e) {
// Queue for retry
await _queueForRetry(change);
}
}
}
}Last-write-wins com detecção de conflitos, queue de retry para offline, recovery service para reconexão.
100+ rotas declarativas com GoRouter, deep linking, redirect guards, e parâmetros tipados.
// app_router.dart - 31,941 bytes, 100+ routes
final goRouter = GoRouter(
initialLocation: '/',
redirect: (context, state) {
final isAuthenticated = ref.read(authProvider).isAuthenticated;
final isOnboarded = ref.read(userProvider).hasCompletedOnboarding;
// Public routes (bypass auth)
if (state.matchedLocation.startsWith('/join/')) return null;
// Auth redirect
if (!isAuthenticated) return '/login';
if (!isOnboarded) return '/onboarding';
return null;
},
routes: [
GoRoute(
path: '/',
builder: (context, state) => const HomeScreen(),
),
GoRoute(
path: '/meditation',
builder: (context, state) => const MeditationListScreen(),
routes: [
GoRoute(
path: 'player',
builder: (context, state) {
final meditation = state.extra as Meditation?;
return MeditationPlayerScreen(meditation: meditation);
},
),
],
),
GoRoute(
path: '/circles/:circleId',
builder: (context, state) {
final circleId = state.pathParameters['circleId']!;
return CircleDetailScreen(circleId: circleId);
},
),
// ... 100+ more routes
],
);Idioma base (app_pt.arb)
app_en.arb
app_es.arb
200+ strings traduzidas usando ARB format (Application Resource Bundle), geração automática via flutter gen-l10n, script Python para tradução em lote.
Este é um dos meus projetos pessoais mais completos em Flutter. Explore também o iContei (rede social de contadores) e os projetos do Optimus.