MAUI Mobile Template - Development Backlog Plan¶

Overview¶

This document provides a comprehensive development backlog plan for ConnectSoft MAUI mobile application templates, structured as Epics with Features and Tasks. The plan is designed for Azure DevOps Boards tracking and follows ConnectSoft engineering standards.

Target Platforms: iOS and Android
Tech Stack: .NET MAUI 9.0, C# 13, XAML, MVVM Community Toolkit, Microsoft.Extensions.* (ILogger, IStringLocalizer), ConnectSoft.Extensions.*, OpenTelemetry

Work Item Structure¶

graph TD
    Epic1[MAUI-EPIC-001<br/>Base MAUI Template Foundation] --> F1[MAUI-FEAT-001<br/>Repository & Solution Structure]
    Epic1 --> F2[MAUI-FEAT-002<br/>Core Infrastructure]
    Epic1 --> F3[MAUI-FEAT-003<br/>Cross-Cutting Concerns]
    Epic1 --> F4[MAUI-FEAT-004<br/>Testing Infrastructure]
    Epic1 --> F5[MAUI-FEAT-005<br/>Template Metadata & CI/CD]
    Epic1 --> F6[MAUI-FEAT-006<br/>Base Template Documentation]

    Epic2[MAUI-EPIC-002<br/>MAUI UIKit Library] --> F7[MAUI-FEAT-007<br/>UIKit Repository & Foundation]
    Epic2 --> F8[MAUI-FEAT-008<br/>Core UI Components]
    Epic2 --> F9[MAUI-FEAT-009<br/>Design Tokens & Theming]
    Epic2 --> F10[MAUI-FEAT-010<br/>Localization & Accessibility]
    Epic2 --> F11[MAUI-FEAT-011<br/>UIKit Testing & Documentation]

    Epic3[MAUI-EPIC-003<br/>Full-Featured Template & Integration] --> F12[MAUI-FEAT-012<br/>Full Template Repository]
    Epic3 --> F13[MAUI-FEAT-013<br/>Application Features]
    Epic3 --> F14[MAUI-FEAT-014<br/>API Integration & Authentication]
    Epic3 --> F15[MAUI-FEAT-015<br/>Offline Support & Platform Features]
    Epic3 --> F16[MAUI-FEAT-016<br/>Full Template Testing & CI/CD]
    Epic3 --> F17[MAUI-FEAT-017<br/>Full Template Documentation]
    Epic3 --> F18[MAUI-FEAT-018<br/>Documentation Repository Updates]

Hold "Alt" / "Option" to enable pan & zoom

ID Naming Convention¶

Epic ID: MAUI-EPIC-XXX (e.g., MAUI-EPIC-001)
Feature ID: MAUI-FEAT-XXX (e.g., MAUI-FEAT-001)
Task ID: MAUI-TASK-XXX (e.g., MAUI-TASK-001)

Epic 1: MAUI-EPIC-001 - Base MAUI Template Foundation¶

Title: Base MAUI Template Foundation - Core Infrastructure and Cross-Cutting Concerns

Description:

Create the foundational base template for MAUI mobile applications (ConnectSoft.MauiBaseTemplate) that provides core infrastructure, cross-cutting concerns (logging, localization, telemetry), and minimal abstractions using built-in .NET/MAUI frameworks. This template serves as the foundation for all specialized MAUI templates, following ConnectSoft's template layering architecture where specialized templates extend the base template via Git submodules and template overlays.

Architecture Principles:

The base template follows a "built-in frameworks first" approach, avoiding custom abstractions for features already provided by .NET Core and MAUI:

Logging: Use ILogger<T> from Microsoft.Extensions.Logging directly - no custom ILoggingService abstraction
Localization: Use IStringLocalizer<T> from Microsoft.Extensions.Localization directly - no custom ILocalizationService abstraction
Navigation: Use MAUI Shell navigation directly (Shell.Current.GoToAsync()) - no custom INavigationService abstraction
Storage: Use SecureStorage and Preferences from Microsoft.Maui.Storage directly - no custom IStorageService abstraction
Connectivity: Use Connectivity from Microsoft.Maui.Networking directly - no custom IConnectivityService abstraction
Lifecycle: Use MAUI's built-in lifecycle events (OnStart, OnSleep, OnResume) - no custom IAppLifecycleService abstraction

Minimal Abstractions:

Only create abstractions when absolutely necessary for testability: - DialogService - Minimal wrapper around Page.DisplayAlert() for testability only - BaseViewModel - MVVM base class with INotifyPropertyChanged and ILogger<T> injection - BaseService - Base service class with ILogger<T> injection

ConnectSoft.Extensions.* Integration:

When built-in features need enhancement, leverage ConnectSoft.Extensions.* libraries: - ConnectSoft.Extensions.Logging - Structured logging extensions, correlation ID support - ConnectSoft.Extensions.Localization - Localization patterns and helpers (if needed) - ConnectSoft.Extensions.Observability - OpenTelemetry integration for telemetry/metrics/traces

Repository Structure:

ConnectSoft.MauiBaseTemplate/
├── .template.config/
│   ├── template.json              # Base template metadata
│   ├── ide.host.json
│   └── dotnetcli.host.json
├── src/
│   ├── MauiBase.Application/      # Main MAUI application
│   │   ├── App.xaml
│   │   ├── App.xaml.cs            # Lifecycle: OnStart, OnSleep, OnResume
│   │   ├── AppShell.xaml
│   │   ├── AppShell.xaml.cs
│   │   └── MauiProgram.cs         # DI setup with built-in services
│   ├── MauiBase.Core/           # Core abstractions (minimal)
│   │   ├── ViewModels/
│   │   │   └── BaseViewModel.cs
│   │   └── Services/
│   │       └── BaseService.cs
│   ├── MauiBase.Infrastructure/  # Infrastructure (minimal wrappers)
│   │   └── Services/
│   │       └── DialogService.cs
│   └── MauiBase.Shared/         # Shared resources
│       ├── Resources/
│       │   ├── Strings/           # Localization resources
│       │   ├── Styles/
│       │   ├── Fonts/
│       │   └── Images/
│       └── Converters/
├── tests/
│   ├── MauiBase.UnitTests/
│   └── MauiBase.IntegrationTests/
├── docs/
│   ├── overview.md
│   ├── architecture.md
│   └── getting-started.md
├── Directory.Build.props
├── Directory.Packages.props
└── ConnectSoft.MauiBaseTemplate.sln

Key Technical Decisions:

No Custom Abstractions for Built-in Features: Navigation, storage, and connectivity use platform APIs directly to avoid unnecessary abstraction layers
ILogger Direct Usage: All services and ViewModels inject ILogger<T> directly, using structured logging patterns
IStringLocalizer Direct Usage: Localization uses IStringLocalizer<T> with resource files (.resx) in Resources/Strings/ folder
Shell Navigation: Use MAUI Shell navigation with route-based navigation and deep linking support
SecureStorage for Sensitive Data: Tokens, credentials stored in SecureStorage; preferences in Preferences
Lifecycle Management: Use MAUI's built-in OnStart(), OnSleep(), OnResume() methods in App.xaml.cs
Template Layering: Base template designed to be extended via Git submodules and template overlays following ConnectSoft patterns

Integration Points:

ConnectSoft.Extensions.Logging: Structured logging extensions, correlation ID tracking
ConnectSoft.Extensions.Observability: OpenTelemetry integration for metrics, traces, distributed tracing
ConnectSoft.Extensions.Localization: Localization patterns (if needed beyond built-in)
Future: ConnectSoft.Maui.UIKit: UI component library integration (created in Epic 2)

Success Criteria:

Template generates working MAUI applications that build and run on iOS and Android
All cross-cutting concerns (logging, localization, telemetry) work out-of-the-box
Template follows ConnectSoft engineering standards (analyzers, code coverage, CI/CD)
Documentation complete and comprehensive
Template can be extended by specialized templates via submodules and overlays

Risks and Mitigations:

Risk: MAUI platform differences between iOS and Android
Mitigation: Test on both platforms early and often, document platform-specific considerations
Risk: Over-abstracting platform APIs
Mitigation: Strict adherence to "built-in frameworks first" principle, code reviews
Risk: Template composition complexity
Mitigation: Follow proven ConnectSoft.BaseTemplate patterns, comprehensive testing

Dependencies:

.NET MAUI 9.0 SDK availability
ConnectSoft.Extensions.* libraries (Logging, Observability, Localization)
ConnectSoft.BaseTemplate patterns for reference

Definition of Done: - Base template repository created with complete solution structure - Core infrastructure implemented using built-in frameworks (ILogger, IStringLocalizer, Shell navigation, SecureStorage, Preferences) - Cross-cutting concerns configured (logging, localization, telemetry/observability) - Application lifecycle management implemented (OnStart, OnSleep, OnResume) - Testing infrastructure established (unit tests, integration tests) - Template metadata configured (.template.config/template.json) - CI/CD pipelines created (build, test, template packaging, documentation) - Base template documentation complete (overview, architecture, getting-started, AGENTS.md) - Template can be used via dotnet new to generate new MAUI applications - Template tested on both iOS and Android platforms - Code coverage meets minimum threshold (70%) - All analyzers pass without errors

Tags: connectsoft, maui, mobile, base-template, foundation, cross-cutting, logging, localization, telemetry, built-in-frameworks, minimal-abstractions

Estimated Duration: 6-8 weeks

Feature 1: MAUI-FEAT-001 - Repository & Solution Structure¶

Description:

Initialize the base MAUI template repository (ConnectSoft.MauiBaseTemplate) with complete solution structure, project organization, build configuration, and engineering baseline. This feature establishes the foundation for all subsequent development work, ensuring the repository follows ConnectSoft engineering standards and is ready for development, testing, and CI/CD integration.

Scope:

This feature includes: - Repository creation with proper folder structure - Solution file with all projects - Build configuration (Directory.Build.props, Directory.Packages.props) - Engineering baseline (analyzers, code quality, warnings as errors) - .NET MAUI 9.0 SDK configuration - Source control setup (.gitignore, README.md)

Technical Approach:

Follow ConnectSoft.BaseTemplate structure as reference
Use .NET MAUI project templates as starting point
Configure Directory.Build.props with ConnectSoft standards
Set up Directory.Packages.props for centralized package version management
Configure analyzers (StyleCop, SonarAnalyzer) from the start
Set up source link and deterministic builds for CI/CD

Project Structure:

The repository will contain: - src/MauiBase.Application/ - Main MAUI application project (entry point) - src/MauiBase.Core/ - Core abstractions (BaseViewModel, BaseService) - src/MauiBase.Infrastructure/ - Infrastructure (minimal wrappers) - src/MauiBase.Shared/ - Shared resources (localization, styles, fonts) - tests/MauiBase.UnitTests/ - Unit test project - tests/MauiBase.IntegrationTests/ - Integration test project - docs/ - Documentation folder - .template.config/ - Template metadata folder

Build Configuration:

Directory.Build.props: Shared build properties, analyzers, nullable context, warnings as errors
Directory.Packages.props: Centralized package version management
.editorconfig: ConnectSoft coding standards
.gitignore: MAUI-specific ignores (bin/, obj/, TestResults/, etc.)

Success Criteria:

Repository structure matches ConnectSoft standards
Solution builds cleanly in Release configuration
All build properties configured correctly
Analyzers active and configured
README.md with clear repository overview

Tags: foundation, repository, solution-structure, build-configuration, engineering-baseline

Task: MAUI-TASK-001¶

Title: Create ConnectSoft.MauiBaseTemplate repository with solution structure

Description: Initialize the base MAUI template repository with complete solution structure, project organization, and build configuration. Set up Directory.Build.props, Directory.Packages.props, and establish engineering baseline following ConnectSoft standards.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - Repository created with proper folder structure: - src/MauiBase.Application/ - Main MAUI application project - src/MauiBase.Core/ - Core abstractions (minimal) - src/MauiBase.Infrastructure/ - Infrastructure (minimal wrappers) - src/MauiBase.Shared/ - Shared resources (localization, styles, fonts) - tests/MauiBase.UnitTests/ - Unit test project - tests/MauiBase.IntegrationTests/ - Integration test project - docs/ - Documentation folder - .template.config/ - Template metadata folder - Solution file (ConnectSoft.MauiBaseTemplate.sln) includes all projects - Directory.Build.props configured with ConnectSoft standards (nullable, analyzers, warnings as errors) - Directory.Packages.props configured with package version management - .NET MAUI 9.0 SDK used throughout - Solution builds cleanly in Release configuration - .gitignore configured for MAUI projects - README.md with repository overview and structure

Implementation Notes: - Follow ConnectSoft.BaseTemplate structure as reference - Use .NET MAUI project templates as starting point - Configure Directory.Build.props similar to ConnectSoft.BaseTemplate - Set up Directory.Packages.props for centralized package version management - Ensure all projects target .NET 9.0 and net9.0-android/net9.0-ios - Configure source link and deterministic builds - Add .editorconfig with ConnectSoft coding standards

Dependencies: None

Estimated Effort: 2 days

Tags: foundation, repository, solution-structure, build-configuration

Task: MAUI-TASK-002¶

Title: Configure build quality gates and analyzers

Description: Set up build quality gates including analyzers (StyleCop, SonarAnalyzer), warnings as errors, code coverage thresholds, and static analysis tools. Configure CI-ready build properties.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - StyleCop.Analyzers configured and active - SonarAnalyzer.CSharp configured - Warnings as errors enabled for Release builds - Code coverage thresholds configured (minimum 70% for new code) - Static analysis tools integrated (if applicable) - Build properties configured for CI/CD (ContinuousIntegrationBuild, Deterministic) - Source link configured for debugging - All analyzers documented in README

Implementation Notes: - Reference ConnectSoft.BaseTemplate Directory.Build.props for analyzer configuration - Use Directory.Build.props for shared build properties - Configure analyzers severity levels appropriately - Set up code coverage collection using coverlet - Ensure analyzers work correctly with MAUI projects - Document any MAUI-specific analyzer configurations

Dependencies: MAUI-TASK-001

Estimated Effort: 1 day

Tags: build-quality, analyzers, code-coverage, static-analysis

Feature 2: MAUI-FEAT-002 - Core Infrastructure¶

Description:

Implement core infrastructure components including BaseViewModel, BaseService, minimal wrappers, and application host setup using built-in .NET/MAUI frameworks. This feature establishes the foundational classes and patterns that all MAUI applications generated from the template will use, following the "built-in frameworks first" principle with minimal abstractions.

Scope:

This feature includes: - MauiBase.Core: BaseViewModel and BaseService classes with ILogger injection - MauiBase.Infrastructure: Minimal DialogService wrapper (for testability only) - MauiBase.Application: MauiProgram.cs, AppShell, App.xaml.cs with lifecycle - Dependency Injection: Service registration and DI container configuration - Navigation Setup: Shell navigation structure and route registration

Technical Approach:

BaseViewModel: MVVM base class with INotifyPropertyChanged, ILogger injection, SetProperty helper, IsBusy property
BaseService: Base service class with ILogger injection, base logging methods
DialogService: Minimal wrapper around Page.DisplayAlert() for testability only
MauiProgram.cs: Configure built-in services (AddLogging, AddLocalization, AddConnectSoftObservability)
AppShell: Shell navigation structure with route registration
App.xaml.cs: Lifecycle methods (OnStart, OnSleep, OnResume)

Key Principles:

No Custom Abstractions: Do NOT create INavigationService, IStorageService, IConnectivityService
Use Built-in Frameworks: Use Shell navigation, SecureStorage, Preferences, Connectivity directly
Minimal Wrappers: Only DialogService wrapper for testability
ILogger Direct Usage: All classes inject ILogger directly from Microsoft.Extensions.Logging

Integration Points:

Microsoft.Extensions.Logging: ILogger for all logging
Microsoft.Extensions.Localization: IStringLocalizer for localization (configured in Feature 3)
ConnectSoft.Extensions.Observability: Telemetry integration (configured in Feature 3)
MAUI Shell: Navigation structure and routing

Success Criteria:

BaseViewModel and BaseService implemented and tested
DialogService wrapper implemented and tested
MauiProgram.cs configured with all services
AppShell navigation structure working
Application lifecycle methods implemented
Application builds and runs on iOS and Android
All services registered in DI container
Unit tests created for base classes

Tags: core, infrastructure, mvvm, base-classes, dependency-injection, built-in-frameworks, minimal-abstractions

Task: MAUI-TASK-003¶

Title: Implement MauiBase.Core with BaseViewModel and BaseService using ILogger

Description: Create the core project with minimal abstractions. Implement BaseViewModel with INotifyPropertyChanged and ILogger injection. Implement BaseService base class with ILogger injection. No custom abstractions for navigation, storage, or connectivity.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - MauiBase.Core project created and referenced by Application project - BaseViewModel class implemented: - Implements INotifyPropertyChanged - Injects ILogger via constructor - Provides SetProperty helper method - Provides IsBusy property for loading states - Provides error handling with logging - BaseService class implemented: - Injects ILogger via constructor - Provides base logging methods - No custom abstractions created - Unit tests created for BaseViewModel and BaseService - Documentation added for base classes usage

Implementation Notes: - Use CommunityToolkit.Mvvm for INotifyPropertyChanged helpers if needed - Follow MVVM patterns from ConnectSoft.BaseTemplate - Use ILogger directly from Microsoft.Extensions.Logging - Do NOT create custom INavigationService, IStorageService, or IConnectivityService - Keep abstractions minimal - only what's necessary for testability - Reference ConnectSoft.BaseTemplate patterns for logging

Dependencies: MAUI-TASK-001

Estimated Effort: 3 days

Tags: core, mvvm, base-classes, logging

Task: MAUI-TASK-004¶

Title: Implement MauiBase.Infrastructure with minimal wrappers

Description: Create infrastructure project with minimal wrappers only for testability. Implement DialogService wrapper around Page.DisplayAlert() for testability. Use SecureStorage, Preferences, Shell navigation, and Connectivity directly without abstractions.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - MauiBase.Infrastructure project created - DialogService implemented as minimal wrapper: - Wraps Page.DisplayAlert() and Page.DisplayActionSheet() - Interface defined for testability only - Registered in DI container - SecureStorage used directly (no abstraction): - Example usage in documentation - No IStorageService abstraction - Preferences used directly (no abstraction): - Example usage in documentation - Shell navigation used directly: - Example usage with Shell.Current.GoToAsync() - No INavigationService abstraction - Connectivity used directly: - Example usage with Connectivity.NetworkAccess - No IConnectivityService abstraction - Unit tests created for DialogService - Documentation added showing direct usage patterns

Implementation Notes: - DialogService is the ONLY wrapper - created only for testability - All other platform APIs used directly (SecureStorage, Preferences, Shell, Connectivity) - Provide examples in documentation showing direct usage - Reference MAUI documentation for SecureStorage and Preferences usage - Use CommunityToolkit.Maui for additional helpers if needed - Keep infrastructure layer minimal - avoid over-abstracting

Dependencies: MAUI-TASK-003

Estimated Effort: 2 days

Tags: infrastructure, wrappers, testability, platform-apis

Task: MAUI-TASK-005¶

Title: Create MauiBase.Application with MauiProgram.cs and AppShell

Description: Set up the main application project with MauiProgram.cs for dependency injection configuration, AppShell for navigation structure, and App.xaml.cs for lifecycle management. Configure built-in services (AddLogging, AddLocalization, AddConnectSoftObservability).

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - MauiBase.Application project created as MAUI application - MauiProgram.cs configured with: - builder.Services.AddLogging() with console and debug providers - builder.Services.AddLocalization() for IStringLocalizer support - builder.Services.AddConnectSoftObservability() for telemetry - DialogService registered in DI - All services properly registered - AppShell.xaml created with basic navigation structure: - Shell navigation routes defined - Basic shell structure (Flyout, TabBar, or simple navigation) - AppShell.xaml.cs created with route registration: - Routing.RegisterRoute() calls for deep linking - App.xaml.cs created with lifecycle methods: - OnStart() method implemented - OnSleep() method implemented - OnResume() method implemented - Application builds and runs on iOS and Android - Basic navigation structure works

Implementation Notes: - Use Microsoft.Extensions.Hosting patterns where applicable - Configure logging with appropriate providers (Console, Debug, Application Insights) - Set up localization with resource files structure - Configure observability with ConnectSoft.Extensions.Observability - Use MAUI Shell navigation patterns - Reference ConnectSoft.BaseTemplate Program.cs for DI patterns - Keep AppShell structure simple but extensible - Document lifecycle method usage

Dependencies: MAUI-TASK-004

Estimated Effort: 3 days

Tags: application, dependency-injection, navigation, lifecycle

Feature 3: MAUI-FEAT-003 - Cross-Cutting Concerns¶

Description:

Implement and configure cross-cutting concerns including localization, logging, telemetry/observability, and application lifecycle management using built-in .NET/MAUI frameworks. This feature ensures all generated MAUI applications have production-ready cross-cutting concerns configured out-of-the-box, following the "built-in frameworks first" principle.

Scope:

This feature includes: - Localization: IStringLocalizer configuration with Resources.resx files - Logging: ILogger configuration with Microsoft.Extensions.Logging and ConnectSoft.Extensions.Logging - Telemetry/Observability: ConnectSoft.Extensions.Observability for OpenTelemetry integration - Lifecycle Management: MAUI built-in lifecycle events (OnStart, OnSleep, OnResume)

Technical Approach:

Localization: - Use IStringLocalizer<T> directly from Microsoft.Extensions.Localization - Resource files (.resx) in Resources/Strings/ folder - Default language: English, example: Spanish - Configure in MauiProgram.cs: builder.Services.AddLocalization() - Example ViewModel showing IStringLocalizer usage

Logging: - Use ILogger<T> directly from Microsoft.Extensions.Logging - Configure in MauiProgram.cs: builder.Services.AddLogging() - Providers: Console, Debug, Application Insights (if applicable) - Integrate ConnectSoft.Extensions.Logging for structured logging extensions - Structured logging patterns: _logger.LogInformation("User {UserId} logged in", userId)

Telemetry/Observability: - Use ConnectSoft.Extensions.Observability for OpenTelemetry - Configure in MauiProgram.cs: builder.Services.AddConnectSoftObservability() - Metrics, traces, distributed tracing - Application Insights integration (if applicable) - Mobile-specific telemetry (battery, network, performance)

Lifecycle Management: - Use MAUI's built-in lifecycle events in App.xaml.cs - OnStart(): App initialization, logging - OnSleep(): State saving using Preferences or SecureStorage - OnResume(): State restoration, background task handling - IHostApplicationLifetime for advanced scenarios (if needed)

Key Principles:

No Custom Abstractions: Use ILogger and IStringLocalizer directly
Built-in Frameworks First: Use Microsoft.Extensions.* directly
ConnectSoft.Extensions.* for Enhancements: Use ConnectSoft libraries for extensions
Lifecycle Events: Use MAUI built-in events, no custom IAppLifecycleService

Integration Points:

Microsoft.Extensions.Localization: IStringLocalizer for localization
Microsoft.Extensions.Logging: ILogger for logging
ConnectSoft.Extensions.Logging: Structured logging extensions, correlation IDs
ConnectSoft.Extensions.Observability: OpenTelemetry integration
MAUI Lifecycle: OnStart, OnSleep, OnResume events

Success Criteria:

Localization configured and working with IStringLocalizer
Logging configured with structured logging patterns
Telemetry configured and sending data to backend
Lifecycle methods implemented and working
All cross-cutting concerns documented
Examples provided for each concern
Works correctly on iOS and Android

Tags: cross-cutting, localization, logging, telemetry, observability, lifecycle, built-in-frameworks, i18n

Task: MAUI-TASK-006¶

Title: Add localization with Resources.resx files and IStringLocalizer configuration

Description: Implement localization support using Microsoft.Extensions.Localization with IStringLocalizer. Create resource files (.resx) in Resources/Strings/ folder. Configure localization in MauiProgram.cs and provide examples of usage in ViewModels.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - Resources/Strings/ folder created in MauiBase.Shared project - Resource files created: - Resources.resx (default/fallback) - Resources.en.resx (English) - Resources.es.resx (Spanish - example) - IStringLocalizer configured in MauiProgram.cs: - builder.Services.AddLocalization() called - Resource file location configured - Example ViewModel created showing IStringLocalizer usage: - Injected via constructor - Used for localized strings - Localization works correctly: - App displays strings from appropriate resource file - Culture switching works (if implemented) - Documentation added: - How to add new resource files - How to use IStringLocalizer in ViewModels - How to add new languages

Implementation Notes: - Use Microsoft.Extensions.Localization directly (no custom abstraction) - Follow ConnectSoft.Extensions.Localization patterns if needed - Create resource files in Shared project for reuse - Configure resource file location in MauiProgram.cs - Provide example showing localized string usage - Reference ConnectSoft.BaseTemplate localization patterns - Document resource file naming conventions - Consider using .resx file generators or tools

Dependencies: MAUI-TASK-005

Estimated Effort: 2 days

Tags: localization, i18n, resources, resx

Task: MAUI-TASK-007¶

Title: Configure ILogger with Microsoft.Extensions.Logging and ConnectSoft.Extensions.Logging extensions

Description: Configure structured logging using ILogger from Microsoft.Extensions.Logging. Integrate ConnectSoft.Extensions.Logging for structured logging extensions. Set up logging providers (Console, Debug, Application Insights) and configure log levels.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - ILogger configured in MauiProgram.cs: - builder.Services.AddLogging() called - Console logging provider added - Debug logging provider added - Application Insights provider configured (if applicable) - ConnectSoft.Extensions.Logging integrated: - Package referenced - Structured logging extensions available - Correlation ID support configured - Logging examples provided: - BaseViewModel logging example - BaseService logging example - Structured logging examples with parameters - Log levels configured appropriately: - Development: Debug level - Production: Information level - Logging works correctly: - Logs appear in console and debug output - Structured logging formats correctly - Correlation IDs included in logs - Documentation added: - How to use ILogger in ViewModels and Services - Structured logging patterns - Log level configuration

Implementation Notes: - Use ILogger directly from Microsoft.Extensions.Logging (no custom abstraction) - Integrate ConnectSoft.Extensions.Logging for extensions - Configure logging providers based on environment - Use structured logging patterns: _logger.LogInformation("User {UserId} logged in", userId) - Set up correlation ID tracking if available - Reference ConnectSoft.BaseTemplate logging configuration - Document logging best practices - Consider Serilog integration if needed (via ConnectSoft.Extensions.Logging.Serilog)

Dependencies: MAUI-TASK-005

Estimated Effort: 2 days

Tags: logging, structured-logging, observability

Task: MAUI-TASK-008¶

Title: Configure ConnectSoft.Extensions.Observability for OpenTelemetry integration

Description: Configure telemetry and observability using ConnectSoft.Extensions.Observability for OpenTelemetry integration. Set up metrics, traces, and distributed tracing. Configure Application Insights or other telemetry backends.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - ConnectSoft.Extensions.Observability package referenced - Observability configured in MauiProgram.cs: - builder.Services.AddConnectSoftObservability() called - OpenTelemetry configured - Application Insights configured (if applicable) - Telemetry collection enabled: - Metrics collection configured - Traces collection configured - Distributed tracing configured (if applicable) - Telemetry examples provided: - Custom metrics example - Custom traces example - Activity tracking example - Telemetry works correctly: - Metrics sent to backend - Traces sent to backend - Application Insights integration works (if configured) - Documentation added: - How to add custom metrics - How to add custom traces - How to configure telemetry backends

Implementation Notes: - Use ConnectSoft.Extensions.Observability for OpenTelemetry - Configure Application Insights or other backends - Set up metrics and traces collection - Consider mobile-specific telemetry (battery, network, performance) - Reference ConnectSoft.BaseTemplate observability configuration - Document telemetry best practices for mobile - Consider privacy implications of telemetry collection - Configure telemetry sampling for production

Dependencies: MAUI-TASK-005

Estimated Effort: 2 days

Tags: telemetry, observability, opentelemetry, application-insights

Task: MAUI-TASK-009¶

Title: Implement application lifecycle management (OnStart, OnSleep, OnResume)

Description: Implement application lifecycle management using MAUI's built-in lifecycle events in App.xaml.cs. Handle app start, sleep, and resume scenarios. Integrate with IHostApplicationLifetime for advanced scenarios.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - App.xaml.cs implements lifecycle methods: - OnStart() method implemented with logging - OnSleep() method implemented with state saving - OnResume() method implemented with state restoration - Lifecycle examples provided: - How to save app state on sleep - How to restore app state on resume - How to handle background tasks - IHostApplicationLifetime integrated (if needed): - Advanced lifecycle scenarios handled - Lifecycle works correctly: - App state saved on sleep - App state restored on resume - Background tasks handled appropriately - Documentation added: - Lifecycle method usage - State management patterns - Background task handling

Implementation Notes: - Use MAUI's built-in lifecycle events (no custom abstraction) - Implement state saving/restoration using Preferences or SecureStorage - Handle background tasks appropriately - Consider platform-specific lifecycle differences - Reference MAUI documentation for lifecycle management - Document best practices for state management - Consider using IHostApplicationLifetime for advanced scenarios - Test lifecycle on both iOS and Android

Dependencies: MAUI-TASK-005

Estimated Effort: 2 days

Tags: lifecycle, app-state, background-tasks

Feature 4: MAUI-FEAT-004 - Testing Infrastructure¶

Description:

Create comprehensive testing infrastructure including unit tests, integration tests, test helpers, and test configuration for MAUI applications. This feature establishes the testing foundation that ensures code quality, enables test-driven development, and supports CI/CD integration with automated test execution.

Scope:

This feature includes: - Unit Test Project: MSTest framework, mocking (Moq/NSubstitute), FluentAssertions - Integration Test Project: Integration test infrastructure, test app factory pattern - Test Infrastructure: Test base classes, test helpers, mock setup helpers - Sample Tests: Unit tests for BaseViewModel, BaseService, DialogService; integration tests for application startup - Test Configuration: Code coverage collection, test runners, CI/CD integration

Technical Approach:

Test Framework: MSTest or xUnit for test execution
Mocking: Moq or NSubstitute for dependency mocking
Assertions: FluentAssertions for readable assertions
Test Base Classes: Common setup, teardown, helper methods
Code Coverage: Coverlet for code coverage collection, minimum 70% threshold
CI/CD Integration: Test projects configured to run in Azure DevOps pipelines

Test Structure:

tests/
├── MauiBase.UnitTests/
│   ├── ViewModels/
│   │   └── BaseViewModelTests.cs
│   ├── Services/
│   │   ├── BaseServiceTests.cs
│   │   └── DialogServiceTests.cs
│   └── Helpers/
│       └── TestBase.cs
└── MauiBase.IntegrationTests/
    ├── Application/
    │   └── ApplicationStartupTests.cs
    └── Infrastructure/
        └── TestAppFactory.cs

Key Testing Patterns:

ViewModel Testing: Test property changes, commands, error handling
Service Testing: Test service methods, logging, error handling
Integration Testing: Test application startup, DI container, service registration
Mocking Patterns: Mock ILogger, IDialogService for unit tests

Success Criteria:

Unit test project created with test infrastructure
Integration test project created with test app factory
Sample tests created and passing
Code coverage meets threshold (70%)
Tests run successfully in CI/CD
Test patterns documented
Test helpers and base classes implemented

Tags: testing, unit-tests, integration-tests, test-infrastructure, code-coverage, tdd

Task: MAUI-TASK-010¶

Title: Create test projects (UnitTests, IntegrationTests) with test infrastructure

Description: Create unit test and integration test projects with test infrastructure, helpers, and sample tests. Set up test configuration, mocking frameworks, and test runners.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - MauiBase.UnitTests project created: - MSTest framework configured - Moq or NSubstitute for mocking - FluentAssertions for assertions - Test helpers and base classes - MauiBase.IntegrationTests project created: - Integration test infrastructure - Test app factory pattern - Test configuration - Sample tests created: - Unit tests for BaseViewModel - Unit tests for BaseService - Unit tests for DialogService - Integration tests for application startup - Test infrastructure implemented: - Test base classes - Test helpers - Mock setup helpers - Tests run successfully: - All unit tests pass - All integration tests pass - Code coverage meets threshold - Documentation added: - How to write unit tests - How to write integration tests - Test patterns and best practices

Implementation Notes: - Use MSTest or xUnit for test framework - Use Moq or NSubstitute for mocking - Use FluentAssertions for readable assertions - Create test base classes for common setup - Reference ConnectSoft.BaseTemplate test infrastructure - Set up code coverage collection - Configure test projects to run in CI/CD - Document test patterns and conventions - Consider MAUI-specific testing challenges

Dependencies: MAUI-TASK-004, MAUI-TASK-005

Estimated Effort: 3 days

Tags: testing, unit-tests, integration-tests, test-infrastructure

Feature 5: MAUI-FEAT-005 - Template Metadata & CI/CD¶

Description:

Create template metadata configuration (.template.config/template.json) and set up CI/CD pipelines for building, testing, packaging, and publishing the template. This feature enables the template to be used via dotnet new and ensures automated quality gates, testing, and template packaging in CI/CD.

Scope:

This feature includes: - Template Metadata: .template.config/template.json with base parameters and post-actions - Main Pipeline: Build, test, publish results and code coverage - Template Packaging Pipeline: Package template as NuGet package, publish to feed - Documentation Pipeline: Generate documentation from markdown, publish to site

Technical Approach:

Template Metadata: - Follow ConnectSoft.BaseTemplate template.json structure - Define base parameters: ServiceName, RootNamespace, UseObservability, UseLocalization - Configure post-actions: restore, build, test (optional) - Template can be installed: dotnet new install <path> - Template can be used: dotnet new connectsoft-maui-base

CI/CD Pipelines: - Main Pipeline (azure-pipelines.yml): Builds on Windows, macOS, Linux; runs tests; publishes results - Template Packaging Pipeline: Packages template, validates structure, publishes to feed - Documentation Pipeline: Generates MkDocs site, validates links, publishes

Pipeline Configuration: - Triggers: PR, main branch - Quality gates: Tests must pass, code coverage threshold - Artifact publishing: Test results, code coverage, template packages - Build agents: macOS for iOS, Windows/Linux for Android

Success Criteria:

Template metadata configured and validated
Template can be installed and used via dotnet new
Generated applications build and run correctly
All CI/CD pipelines execute successfully
Template packages published to feed
Documentation generated and published
Quality gates enforced

Tags: template-metadata, cicd, azure-devops, packaging, dotnet-new, quality-gates

Task: MAUI-TASK-011¶

Title: Create .template.config/template.json with base parameters and post-actions

Description: Create template metadata configuration for dotnet new template. Define base parameters (ServiceName, RootNamespace, etc.), configure post-actions, and set up template structure.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - .template.config/template.json created: - Template identity and metadata defined - Base parameters defined (ServiceName, RootNamespace, etc.) - Post-actions configured (restore, build, test) - Template structure defined - Template parameters include: - ServiceName (string, required) - RootNamespace (string, optional) - UseObservability (bool, default true) - UseLocalization (bool, default true) - Post-actions configured: - Restore NuGet packages - Build solution - Run tests (optional) - Template can be installed locally: - dotnet new install works - dotnet new connectsoft-maui-base works - Template generates working application: - Generated app builds successfully - Generated app runs on iOS and Android - Documentation added: - Template parameter reference - How to use the template - How to customize the template

Implementation Notes: - Follow ConnectSoft.BaseTemplate template.json structure - Use template.json schema for validation - Define parameters following ConnectSoft naming conventions - Configure post-actions for common setup tasks - Test template generation end-to-end - Reference dotnet new template documentation - Document all template parameters - Consider template extend files for specialized templates

Dependencies: MAUI-TASK-010

Estimated Effort: 2 days

Tags: template-metadata, dotnet-new, parameters, post-actions

Task: MAUI-TASK-012¶

Title: Create Azure DevOps pipelines (main, template packaging, documentation)

Description: Create Azure DevOps pipelines for building, testing, packaging, and publishing the base template. Set up pipelines for main branch, template packaging, and documentation generation.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - Main pipeline created (azure-pipelines.yml): - Builds solution on Windows, macOS, Linux - Runs unit tests - Runs integration tests - Publishes test results - Publishes code coverage - Template packaging pipeline created: - Packages template as NuGet package - Publishes template to feed - Validates template structure - Documentation pipeline created: - Generates documentation from markdown - Publishes to documentation site - Validates documentation links - Pipelines configured with: - Proper triggers (PR, main branch) - Quality gates (tests must pass) - Artifact publishing - Pipelines run successfully: - All pipelines execute without errors - Artifacts published correctly - Documentation generated correctly - Documentation added: - Pipeline configuration reference - How to trigger pipelines - Pipeline troubleshooting guide

Implementation Notes: - Reference ConnectSoft.BaseTemplate azure-pipelines.yml - Use Azure DevOps YAML pipeline syntax - Configure build agents for MAUI (macOS for iOS, Windows/Linux for Android) - Set up test result publishing - Configure code coverage publishing - Set up template packaging workflow - Configure documentation generation (MkDocs) - Document pipeline configuration - Consider pipeline templates for reuse

Dependencies: MAUI-TASK-011

Estimated Effort: 3 days

Tags: cicd, azure-devops, pipelines, packaging

Feature 6: MAUI-FEAT-006 - Base Template Documentation¶

Description:

Create comprehensive documentation for the base template including overview, architecture, getting-started guide, and AGENTS.md for AI coding agents. This feature ensures developers and AI coding agents have complete, accurate documentation to understand and use the base template effectively.

Scope:

This feature includes: - Overview Documentation: Template purpose, use cases, key features - Architecture Documentation: Architecture diagrams, patterns, design decisions - Getting Started Guide: Step-by-step guide to using the template - AGENTS.md: AI coding agent reference with patterns, examples, guidelines - MkDocs Configuration: Navigation structure, theme, plugins

Documentation Structure:

docs/
├── overview.md              # Template overview and purpose
├── architecture.md          # Architecture documentation
├── getting-started.md       # Getting started guide
└── AGENTS.md                # AI coding agent reference

Content Requirements:

Overview: - Template purpose and use cases - Key features and capabilities - When to use the base template - Relationship to specialized templates

Architecture: - Architecture diagrams (Mermaid) - Design patterns used - Built-in framework usage (ILogger, IStringLocalizer, etc.) - What NOT to abstract (navigation, storage, etc.) - Template layering and composition

Getting Started: - Installation steps - Template generation steps - First application creation - Basic configuration - Running on iOS and Android

AGENTS.md: - Template structure and patterns - Code generation guidelines - Built-in framework usage patterns - What to abstract vs. what to use directly - Common patterns and examples - Anti-patterns to avoid

Success Criteria:

All documentation files created and complete
MkDocs site generates successfully
All links work correctly
Diagrams render correctly
Code examples work
Documentation follows ConnectSoft standards
AGENTS.md comprehensive for AI coding agents

Tags: documentation, overview, architecture, getting-started, agents, mkdocs, ai-coding-agents

Task: MAUI-TASK-013¶

Title: Create documentation (overview.md, architecture.md, getting-started.md, AGENTS.md) and configure mkdocs.yml

Description: Create comprehensive documentation for the base template including overview, architecture documentation, getting-started guide, and AGENTS.md for AI coding agents. Configure MkDocs for documentation site generation.

Repository: ConnectSoft.MauiBaseTemplate

Acceptance Criteria: - Documentation files created: - docs/overview.md - Template overview and purpose - docs/architecture.md - Architecture documentation - docs/getting-started.md - Getting started guide - AGENTS.md - AI coding agent reference - Documentation includes: - Template purpose and use cases - Architecture diagrams and patterns - Getting started steps - Code examples and patterns - Best practices - Troubleshooting guide - mkdocs.yml configured: - Navigation structure defined - Theme configured - Plugins configured - Documentation site generates successfully: - MkDocs build succeeds - All links work - Diagrams render correctly - Documentation published: - Available in documentation site - Searchable and navigable - Documentation quality: - Clear and comprehensive - Code examples work - Follows ConnectSoft documentation standards

Implementation Notes: - Reference ConnectSoft.BaseTemplate AGENTS.md structure - Use Mermaid diagrams for architecture visualization - Include code examples for all major patterns - Document built-in framework usage (ILogger, IStringLocalizer, etc.) - Document what NOT to abstract (navigation, storage, etc.) - Follow ConnectSoft documentation standards - Use MkDocs Material theme - Configure search and navigation - Document template parameters - Include troubleshooting section

Dependencies: MAUI-TASK-011

Estimated Effort: 4 days

Tags: documentation, mkdocs, overview, architecture, getting-started

Epic 2: MAUI-EPIC-002 - MAUI UIKit Library¶

Title: MAUI UIKit Library - Reusable UI Component Library

Description:

Create ConnectSoft.Maui.UIKit - a reusable UI component library for MAUI applications, similar to ConnectSoft.Blazor.UIKit. The library provides accessible, localized, and themed UI components with design tokens support. This library will be consumed by the base template and full-featured template as a NuGet package, enabling consistent UI components across all MAUI applications generated from ConnectSoft templates.

Purpose and Value:

The UIKit library addresses the need for consistent, production-ready UI components across MAUI applications. It provides: - Reusable Components: Button, TextField, Dialog, Toast, Card, List, and other essential components - Design System: Design tokens (colors, spacing, typography) with light/dark theme support - Accessibility: WCAG 2.1 AA compliant components with screen reader support - Localization: Built-in localization support using IStringLocalizer<T> - Consistency: Ensures all ConnectSoft MAUI applications have consistent UI/UX

Architecture and Design:

The UIKit library follows a component-based architecture: - Component Library: Core UIKit library project containing all components - Design Tokens: XAML ResourceDictionary with colors, spacing, typography, themes - Localization: Resource files for component strings using IStringLocalizer<T> - Accessibility: AutomationProperties, SemanticLabel, keyboard navigation support - Sample App: Comprehensive sample app demonstrating all components and features - NuGet Package: Published as NuGet package for consumption by templates

Component Structure:

ConnectSoft.Maui.UIKit/
├── src/
│   ├── ConnectSoft.Maui.UIKit/       # Core UIKit library
│   │   ├── Components/
│   │   │   ├── Button/
│   │   │   │   ├── UIKitButton.xaml
│   │   │   │   ├── UIKitButton.xaml.cs
│   │   │   │   └── UIKitButtonViewModel.cs (if needed)
│   │   │   ├── TextField/
│   │   │   ├── Dialog/
│   │   │   ├── Toast/
│   │   │   ├── Card/
│   │   │   └── List/
│   │   ├── Styles/
│   │   │   ├── DesignTokens.xaml      # Design tokens
│   │   │   └── Themes.xaml            # Light/Dark themes
│   │   ├── Resources/
│   │   │   └── Strings/               # Localized strings
│   │   └── Extensions/
│   │       └── MauiProgramExtensions.cs
│   └── ConnectSoft.Maui.UIKit.Samples/ # Sample app
├── tests/
│   └── ConnectSoft.Maui.UIKit.Tests/
└── docs/

Key Technical Decisions:

Design Tokens in XAML: Use XAML ResourceDictionary for design tokens to enable runtime theme switching
IStringLocalizer for Localization: Use built-in localization framework, no custom abstraction
Accessibility First: All components designed with accessibility in mind from the start
MVVM Support: Components support data binding and MVVM patterns
Theme Support: Light and dark themes with system theme detection
NuGet Package: Published as NuGet package for easy consumption

Component Requirements:

Each component must: - Support theming (light/dark mode) - Support localization (all user-facing strings) - Be accessible (WCAG 2.1 AA compliant) - Support data binding and MVVM patterns - Have comprehensive unit tests - Have documentation with usage examples - Follow MAUI best practices

Design Token System:

Design tokens defined in XAML ResourceDictionary: - Colors: Primary, Secondary, Success, Error, Warning, Info, Background, Surface, Text - Spacing: xs (4px), sm (8px), md (16px), lg (24px), xl (32px), etc. - Typography: Headings (H1-H6), Body, Caption, Button text - Border Radius: Small, Medium, Large - Shadows/Elevation: Levels 0-24 (Material Design inspired)

Localization Approach:

Use IStringLocalizer<T> directly (no custom abstraction)
Resource files in Resources/Strings/ folder
Default language: English
Support for additional languages (Spanish, French, etc.)
All component strings localized (button labels, dialog messages, error messages)

Accessibility Requirements:

WCAG 2.1 AA Compliance: All components meet accessibility standards
Screen Reader Support: SemanticLabel and AutomationProperties configured
Keyboard Navigation: All interactive components keyboard accessible
Focus Management: Proper focus indicators and focus order
Color Contrast: All text meets contrast ratio requirements

Integration with Base Template:

The UIKit library will be integrated into the base template:

<PackageReference Include="ConnectSoft.Maui.UIKit" Version="1.0.0" />

Configured in MauiProgram.cs:

builder.Services.AddMauiUIKit(options =>
{
    options.UseDefaultTheme();
    options.EnableLocalization();
});

Success Criteria:

UIKit library published as NuGet package
All core components implemented and tested
Design tokens system complete with light/dark themes
Localization support working for all components
Accessibility features implemented and tested
Sample app demonstrates all components
Component documentation complete
UIKit integrated with base template
Components work on both iOS and Android

Risks and Mitigations:

Risk: Component complexity and maintenance overhead
Mitigation: Start with essential components, expand based on needs
Risk: Design token system complexity
Mitigation: Follow established design systems (Material Design), document clearly
Risk: Accessibility compliance challenges
Mitigation: Test with screen readers early, follow WCAG guidelines strictly

Dependencies:

Base template (Epic 1) for integration patterns
ConnectSoft.Blazor.UIKit for reference patterns
.NET MAUI 9.0 SDK

Definition of Done: - UIKit repository created with complete solution structure - Core UI components implemented (Button, TextField, Dialog, Toast, Card, List, etc.) - Design tokens system implemented (colors, spacing, typography, themes) - Localization support integrated using IStringLocalizer - Accessibility features implemented (WCAG 2.1 AA compliance) - Sample app demonstrating all components - Comprehensive testing (unit tests, accessibility tests) - Component documentation complete - NuGet package published and available - UIKit integrated with base template - All components tested on iOS and Android - Code coverage meets minimum threshold (80% for components)

Tags: connectsoft, maui, uikit, components, design-tokens, accessibility, localization, reusable-components, design-system

Estimated Duration: 6-8 weeks

Feature 7: MAUI-FEAT-007 - UIKit Repository & Foundation¶

Description:

Initialize the MAUI UIKit repository (ConnectSoft.Maui.UIKit) with complete solution structure, project organization, and foundation setup. This feature establishes the foundation for the reusable UI component library that will be consumed by all MAUI templates as a NuGet package.

Scope:

This feature includes: - Repository creation with proper folder structure - Core UIKit library project (MAUI class library) - Sample app project for component demonstration - Test project for component testing - Build configuration (Directory.Build.props, Directory.Packages.props) - NuGet package configuration for publishing

Technical Approach:

Reference ConnectSoft.Blazor.UIKit structure for consistency
Use MAUI class library project type for core library
Configure for NuGet package publishing (.csproj with PackageId, Version, etc.)
Set up build configuration for iOS and Android targets
Configure analyzers and code quality from the start

Repository Structure:

ConnectSoft.Maui.UIKit/
├── src/
│   ├── ConnectSoft.Maui.UIKit/       # Core UIKit library
│   └── ConnectSoft.Maui.UIKit.Samples/ # Sample app
├── tests/
│   └── ConnectSoft.Maui.UIKit.Tests/
├── docs/
├── Directory.Build.props
├── Directory.Packages.props
└── ConnectSoft.Maui.UIKit.sln

Success Criteria:

Repository structure matches ConnectSoft standards
Solution builds cleanly
NuGet package configuration ready
README.md with repository overview
Build configuration complete

Tags: foundation, repository, uikit, solution-structure, nuget-package

Task: MAUI-TASK-014¶

Title: Create ConnectSoft.Maui.UIKit repository with solution structure

Description: Initialize the MAUI UIKit repository with complete solution structure including core library project, sample app project, test project, and documentation structure.

Repository: ConnectSoft.Maui.UIKit

Acceptance Criteria: - Repository created with proper folder structure: - src/ConnectSoft.Maui.UIKit/ - Core UIKit library project - src/ConnectSoft.Maui.UIKit.Samples/ - Sample app project - tests/ConnectSoft.Maui.UIKit.Tests/ - Test project - docs/ - Documentation folder - Solution file created with all projects - Directory.Build.props and Directory.Packages.props configured - .NET MAUI 9.0 SDK used - Solution builds cleanly - README.md with repository overview

Implementation Notes: - Reference ConnectSoft.Blazor.UIKit structure - Use MAUI class library project type - Configure for NuGet package publishing - Set up build configuration for iOS and Android - Configure analyzers and code quality

Dependencies: None

Estimated Effort: 1 day

Tags: foundation, repository, uikit

Feature 8: MAUI-FEAT-008 - Core UI Components¶

Description:

Implement core UI components including Button, TextField, Dialog, Toast, Card, List, and other essential components. These components form the foundation of the UIKit library and must be production-ready, accessible, localized, and themed. Each component should follow MAUI best practices, support data binding and MVVM patterns, and be fully documented.

Scope:

This feature includes implementation of: - Button Component: Variants (Primary, Secondary, Outline, Text), sizes, loading/disabled states - TextField Component: Input types, validation, error states, helper text - Dialog Component: Modal dialogs, action buttons, customizable content - Toast Component: Variants (Success, Error, Warning, Info), auto/manual dismiss - Card Component: Header, body, footer sections, variants - List Component: Item templates, selection, grouping

Component Requirements:

Each component must: - Support theming (light/dark mode via design tokens) - Support localization (all user-facing strings via IStringLocalizer) - Be accessible (WCAG 2.1 AA compliant, SemanticLabel, AutomationProperties) - Support data binding and MVVM patterns - Have comprehensive unit tests - Have documentation with usage examples - Follow MAUI best practices

Technical Approach:

Use MAUI Controls and Views as base
Implement proper styling with Style resources (using design tokens)
Support data binding with BindableProperty
Ensure accessibility from the start (SemanticLabel, AutomationProperties)
Create reusable component base classes if needed
Document component APIs and usage patterns

Component Structure Example:

// UIKitButton.xaml.cs
public partial class UIKitButton : Button
{
    public static readonly BindableProperty VariantProperty = ...
    public static readonly BindableProperty SizeProperty = ...
    public static readonly BindableProperty IsLoadingProperty = ...

    // Properties, events, accessibility setup
}

Success Criteria:

All core components implemented
Components support theming, localization, accessibility
Components have unit tests (minimum 80% coverage)
Components have documentation
Components work on iOS and Android
Components follow MAUI best practices

Tags: components, ui, button, textfield, dialog, toast, card, list, accessibility, localization, theming

Task: MAUI-TASK-015¶

Title: Implement core UIKit components (Button, TextField, Dialog, Toast, Card, List)

Description: Implement core UI components with proper styling, behavior, and accessibility. Components should be reusable, customizable, and follow MAUI best practices.

Repository: ConnectSoft.Maui.UIKit

Acceptance Criteria: - Button component implemented: - Variants (Primary, Secondary, Outline, Text) - Sizes (Small, Medium, Large) - Loading state support - Disabled state support - Accessibility support - TextField component implemented: - Input types (Text, Email, Password, Number) - Validation support - Error state display - Helper text support - Accessibility support - Dialog component implemented: - Modal dialog support - Action buttons - Customizable content - Accessibility support - Toast component implemented: - Success, Error, Warning, Info variants - Auto-dismiss support - Manual dismiss support - Accessibility support - Card component implemented: - Header, Body, Footer sections - Customizable content - Variants - List component implemented: - Item templates - Selection support - Grouping support - All components: - Follow MAUI best practices - Support theming - Support localization - Have unit tests - Have documentation

Implementation Notes: - Reference ConnectSoft.Blazor.UIKit component patterns - Use MAUI Controls and Views - Implement proper styling with Style resources - Support data binding and MVVM patterns - Ensure accessibility from the start - Create reusable component base classes if needed - Document component APIs and usage

Dependencies: MAUI-TASK-014

Estimated Effort: 8 days

Tags: components, ui, accessibility

Feature 9: MAUI-FEAT-009 - Design Tokens & Theming¶

Description:

Implement design tokens system with colors, spacing, typography, and light/dark theme support. This feature creates a comprehensive design system that ensures visual consistency across all UIKit components and enables easy theme customization. The design tokens are defined in XAML ResourceDictionary to support runtime theme switching.

Scope:

This feature includes: - Design Tokens XAML: Colors, spacing, typography, border radius, shadows/elevation - Light Theme: All color tokens for light mode with proper contrast ratios - Dark Theme: All color tokens for dark mode with proper contrast ratios - Theme Switching: Support for switching between light and dark themes - System Theme Detection: Automatic theme detection based on system preferences

Design Token Categories:

Colors: - Primary, Secondary, Success, Error, Warning, Info - Background, Surface, Text (Primary, Secondary, Disabled) - Border, Divider colors - All colors defined for both light and dark themes

Spacing: - Scale: xs (4px), sm (8px), md (16px), lg (24px), xl (32px), xxl (48px) - Used for margins, padding, gaps

Typography: - Headings: H1-H6 with font sizes, weights, line heights - Body: Regular, Medium, Bold variants - Caption: Small text for labels, hints - Button: Button text styles

Other Tokens: - Border Radius: Small, Medium, Large - Shadows/Elevation: Levels 0-24 (Material Design inspired)

Technical Approach:

Use XAML ResourceDictionary for all tokens
Follow Material Design or similar design system principles
Ensure WCAG contrast ratios for all text/background combinations
Support system theme detection (Application.UserAppTheme)
Enable runtime theme switching
Document token naming conventions

Theme Structure:

<!-- DesignTokens.xaml -->
<ResourceDictionary>
    <!-- Light Theme Colors -->
    <Color x:Key="PrimaryColor">#6200EE</Color>
    <Color x:Key="BackgroundColor">#FFFFFF</Color>
    <!-- ... -->

    <!-- Dark Theme Colors -->
    <Color x:Key="PrimaryColorDark">#BB86FC</Color>
    <Color x:Key="BackgroundColorDark">#121212</Color>
    <!-- ... -->

    <!-- Spacing -->
    <x:Double x:Key="SpacingXS">4</x:Double>
    <x:Double x:Key="SpacingSM">8</x:Double>
    <!-- ... -->
</ResourceDictionary>

Success Criteria:

Design tokens defined for all categories
Light and dark themes complete
Theme switching works correctly
All components use design tokens (no hard-coded values)
WCAG contrast ratios met
System theme detection works
Token customization guide documented

Tags: design-tokens, theming, colors, spacing, typography, light-theme, dark-theme, material-design

Task: MAUI-TASK-016¶

Title: Create DesignTokens.xaml with colors, spacing, typography, and light/dark theme support

Description: Create comprehensive design tokens system using XAML resources. Define colors, spacing, typography, and support for light and dark themes.

Repository: ConnectSoft.Maui.UIKit

Acceptance Criteria: - DesignTokens.xaml created: - Color palette defined (Primary, Secondary, Success, Error, Warning, Info) - Spacing scale defined (xs, sm, md, lg, xl, etc.) - Typography scale defined (Headings, Body, Caption, etc.) - Border radius tokens defined - Shadow/elevation tokens defined - Light theme defined: - All color tokens for light mode - Proper contrast ratios - Dark theme defined: - All color tokens for dark mode - Proper contrast ratios - Theme switching support: - App can switch between light and dark themes - Components adapt to theme changes - Design tokens used in components: - All components use design tokens - No hard-coded colors or spacing - Documentation added: - Design token reference - How to customize tokens - How to add new themes

Implementation Notes: - Use XAML ResourceDictionary for tokens - Follow Material Design or similar design system - Ensure WCAG contrast ratios - Support system theme detection - Reference ConnectSoft.Blazor.UIKit design tokens - Document token naming conventions - Provide token customization guide

Dependencies: MAUI-TASK-014

Estimated Effort: 3 days

Tags: design-tokens, theming, colors, spacing

Feature 10: MAUI-FEAT-010 - Localization & Accessibility¶

Description:

Add localization support using IStringLocalizer and implement comprehensive accessibility features for all UIKit components. This feature ensures the UIKit library is internationalized and accessible to all users, meeting WCAG 2.1 AA compliance standards and supporting multiple languages.

Scope:

This feature includes: - Localization: IStringLocalizer support with resource files for component strings - Accessibility: ARIA labels, keyboard navigation, screen reader compatibility, WCAG 2.1 AA compliance - Component Localization: All user-facing strings in components localized - Accessibility Testing: Components tested with screen readers, keyboard navigation tested

Localization Approach:

Use IStringLocalizer<T> directly (no custom abstraction)
Resource files in Resources/Strings/ folder
Default language: English
Support for additional languages (Spanish, French, etc.)
All component strings localized:
Button labels
Dialog titles and messages
Toast messages
Error messages
Helper text

Accessibility Requirements:

WCAG 2.1 AA Compliance: All components meet accessibility standards
Screen Reader Support: SemanticLabel and AutomationProperties configured for all interactive elements
Keyboard Navigation: All interactive components keyboard accessible with proper focus order
Focus Management: Proper focus indicators and focus order
Color Contrast: All text meets contrast ratio requirements (4.5:1 for normal text, 3:1 for large text)

Technical Implementation:

Localization:

// Component uses IStringLocalizer<T>
public class UIKitButton : Button
{
    private readonly IStringLocalizer<UIKitButton> _localizer;

    public string LocalizedText => _localizer["ButtonText"];
}

Accessibility:

// Set SemanticLabel and AutomationProperties
AutomationProperties.SetName(button, "Submit");
AutomationProperties.SetHelpText(button, "Submit the form");
SemanticProperties.SetHint(button, "Double tap to submit");

Success Criteria:

All component strings localized
Localization works correctly with language switching
All components accessible (WCAG 2.1 AA compliant)
Components tested with screen readers (VoiceOver, TalkBack)
Keyboard navigation works for all components
Accessibility tests created and passing
Localization and accessibility documented

Tags: localization, accessibility, i18n, wcag, screen-readers, keyboard-navigation, semantic-labels

Task: MAUI-TASK-017¶

Title: Add localization support using IStringLocalizer with resource files for component strings

Description: Implement localization support for UIKit components using IStringLocalizer. Create resource files for component strings and ensure all user-facing text is localized.

Repository: ConnectSoft.Maui.UIKit

Acceptance Criteria: - Localization configured: - IStringLocalizer support added - Resource files created for component strings - Default language (English) defined - Component strings localized: - Button labels - Dialog titles and messages - Toast messages - Error messages - Helper text - Localization examples provided: - How to use localized components - How to add new languages - Localization works correctly: - Components display localized strings - Language switching works - Documentation added: - Localization guide - How to add new languages

Implementation Notes: - Use IStringLocalizer directly (no custom abstraction) - Create resource files in Resources/Strings/ folder - Localize all user-facing strings - Provide examples for common languages - Reference ConnectSoft.Blazor.UIKit localization patterns - Document localization best practices

Dependencies: MAUI-TASK-015

Estimated Effort: 2 days

Tags: localization, i18n, resources

Task: MAUI-TASK-018¶

Title: Implement accessibility features (ARIA labels, keyboard navigation, WCAG 2.1 AA compliance)

Description: Implement comprehensive accessibility features for all UIKit components. Ensure WCAG 2.1 AA compliance, keyboard navigation support, and screen reader compatibility.

Repository: ConnectSoft.Maui.UIKit

Acceptance Criteria: - Accessibility implemented for all components: - SemanticLabel properties set - AutomationProperties configured - Keyboard navigation support - Focus management - Screen reader compatibility - WCAG 2.1 AA compliance: - Color contrast ratios meet requirements - Text alternatives provided - Keyboard accessible - Focus indicators visible - Accessibility testing: - Components tested with screen readers - Keyboard navigation tested - Accessibility tests created - Documentation added: - Accessibility guide - WCAG compliance checklist - Testing guidelines

Implementation Notes: - Use MAUI AutomationProperties - Set SemanticLabel for all interactive elements - Ensure keyboard navigation works - Test with screen readers (VoiceOver, TalkBack) - Follow WCAG 2.1 AA guidelines - Reference ConnectSoft.Blazor.UIKit accessibility patterns - Document accessibility best practices - Create accessibility test suite

Dependencies: MAUI-TASK-015

Estimated Effort: 4 days

Tags: accessibility, wcag, screen-readers, keyboard-navigation

Feature 11: MAUI-FEAT-011 - UIKit Testing & Documentation¶

Description:

Create comprehensive testing infrastructure and documentation for the UIKit library. This feature ensures the UIKit library is well-tested, well-documented, and provides clear examples for developers using the components. The sample app serves as both a showcase and a reference implementation.

Scope:

This feature includes: - Sample App: Comprehensive component gallery demonstrating all components, theming, and localization - Unit Tests: Tests for all components (behavior, state, interactions) - Accessibility Tests: Tests for SemanticLabel, keyboard navigation, screen reader compatibility - Component Documentation: API reference, usage examples, theming guide, best practices - MkDocs Configuration: Documentation site with navigation and search

Sample App Requirements:

The sample app should demonstrate: - Component Gallery: All components with all variants and states - Theme Switcher: Switch between light and dark themes - Language Switcher: Switch between different languages - Interactive Examples: Working examples of component usage - Code Examples: Show code for each component usage

Testing Requirements:

Unit Tests: Test component behavior, state changes, interactions
Accessibility Tests: Test SemanticLabel properties, keyboard navigation, screen reader compatibility
Test Coverage: Minimum 80% code coverage for components
Test Infrastructure: Component test base classes, accessibility test helpers

Documentation Requirements:

Component API Reference: Properties, events, methods for each component
Usage Examples: Code examples for each component
Theming Guide: How to use design tokens, customize themes, create custom themes
Best Practices: Component usage patterns, accessibility guidelines, localization guidelines
MkDocs Site: Searchable, navigable documentation site

Success Criteria:

Sample app created and runs on iOS and Android
All components demonstrated in sample app
Unit tests created with 80%+ coverage
Accessibility tests created and passing
Component documentation complete
Documentation site generates successfully
All examples work correctly

Tags: testing, documentation, samples, uikit, component-gallery, api-reference, theming-guide

Task: MAUI-TASK-019¶

Title: Create sample app demonstrating all components, theming, and localization

Description: Create a comprehensive sample app that demonstrates all UIKit components, theming capabilities, and localization features. The sample app should serve as both a showcase and a reference implementation.

Repository: ConnectSoft.Maui.UIKit

Acceptance Criteria: - Sample app created: - All components demonstrated - Theming examples (light/dark) - Localization examples (multiple languages) - Interactive examples - Sample app features: - Component gallery - Theme switcher - Language switcher - Code examples - Sample app runs on iOS and Android: - All examples work correctly - Navigation works - Theming works - Localization works - Documentation added: - How to run the sample app - Component usage examples

Implementation Notes: - Create comprehensive component gallery - Show all component variants and states - Demonstrate theming and localization - Provide code examples for each component - Make sample app visually appealing - Reference ConnectSoft.Blazor.UIKit sample app

Dependencies: MAUI-TASK-016, MAUI-TASK-017, MAUI-TASK-018

Estimated Effort: 3 days

Tags: samples, demo, showcase

Task: MAUI-TASK-020¶

Title: Create unit tests and accessibility tests for UIKit components

Description: Create comprehensive test suite for UIKit components including unit tests for behavior and accessibility tests for WCAG compliance.

Repository: ConnectSoft.Maui.UIKit

Acceptance Criteria: - Unit tests created: - Tests for all components - Behavior tests - State tests - Interaction tests - Accessibility tests created: - SemanticLabel tests - Keyboard navigation tests - Screen reader compatibility tests - Test coverage: - Minimum 80% code coverage - All critical paths tested - Tests run successfully: - All unit tests pass - All accessibility tests pass - Documentation added: - Test patterns - How to add new tests

Implementation Notes: - Use MSTest or xUnit - Create component test base classes - Test component behavior and interactions - Create accessibility test helpers - Reference ConnectSoft.Blazor.UIKit test patterns - Document test patterns and conventions

Dependencies: MAUI-TASK-015

Estimated Effort: 4 days

Tags: testing, unit-tests, accessibility-tests

Task: MAUI-TASK-021¶

Title: Create component documentation, usage examples, and theming guide

Description: Create comprehensive documentation for UIKit components including API reference, usage examples, theming guide, and best practices.

Repository: ConnectSoft.Maui.UIKit

Acceptance Criteria: - Component documentation created: - API reference for each component - Usage examples - Property descriptions - Event descriptions - Theming guide created: - How to use design tokens - How to customize themes - How to create custom themes - Usage examples provided: - Code examples for each component - Common patterns - Best practices - Documentation site configured: - MkDocs configuration - Navigation structure - Search functionality - Documentation quality: - Clear and comprehensive - Code examples work - Follows ConnectSoft standards

Implementation Notes: - Use XML documentation comments - Generate API docs from code - Create usage examples for each component - Document theming and customization - Reference ConnectSoft.Blazor.UIKit documentation - Use MkDocs for documentation site - Include interactive examples if possible

Dependencies: MAUI-TASK-019

Estimated Effort: 3 days

Tags: documentation, api-reference, examples

Epic 3: MAUI-EPIC-003 - Full-Featured Template & Integration¶

Title: Full-Featured MAUI Template & Documentation Integration

Description:

Create the full-featured MAUI template (ConnectSoft.MauiTemplate) that extends the base template with production-ready features including API integration, authentication, offline support, and platform features. This template demonstrates how to build a complete, production-ready MAUI application using the base template as a foundation. Update all documentation repositories with mobile template information to ensure the MAUI templates are properly integrated into ConnectSoft's template ecosystem.

Template Layering Architecture:

The full-featured template follows ConnectSoft's template layering patterns: - Base Template as Submodule: Includes ConnectSoft.MauiBaseTemplate as Git submodule - Template Overlay: Uses template extend files (maui.template.extend.json) to extend base template.json - Build-Time Extension: Solution includes both base template projects and full-featured projects - Generation-Time Composition: Template generator merges base + full-featured overlays

Repository Structure:

ConnectSoft.MauiTemplate/
├── base-template/                    # Git submodule -> ConnectSoft.MauiBaseTemplate
├── src/
│   ├── MauiApp.Application/         # Full-featured application
│   │   ├── Views/                    # LoginPage, HomePage, DetailsPage, SettingsPage
│   │   ├── ViewModels/               # ViewModels for each View
│   │   ├── Services/                # API clients, sync service, etc.
│   │   ├── Models/                  # Data models, DTOs
│   │   └── Infrastructure/          # Platform feature implementations
│   ├── MauiApp.Domain/               # Domain logic (if needed)
│   └── MauiApp.Infrastructure/      # Infrastructure implementations
│       ├── Api/                      # Refit API clients
│       ├── Auth/                     # MSAL authentication
│       ├── Database/                 # SQLite database, repositories
│       └── Platform/                 # Platform feature wrappers (if needed)
├── tests/
│   ├── MauiApp.UnitTests/
│   ├── MauiApp.IntegrationTests/
│   └── MauiApp.UITests/
├── docs/
│   ├── maui-overview.md
│   ├── api-integration.md
│   ├── offline-support.md
│   ├── platform-features.md
│   └── deployment.md
├── template/
│   └── maui.template.extend.json     # Extends base template.json
└── ConnectSoft.MauiTemplate.sln

Key Features:

Application Features:
Complete Views and ViewModels following MVVM patterns
Shell navigation structure with deep linking
Example pages (Login, Home, Details, Settings)
API Integration:
Refit clients for REST API communication
Polly retry policies with exponential backoff
Circuit breaker pattern for resilience
Global error handling
Automatic token refresh on 401 responses
Authentication:
MSAL (Microsoft Identity Client) integration
OAuth2 flows (Azure AD, Google, etc.)
Token storage in SecureStorage
Automatic token refresh
Protected routes and authentication state management
Offline Support:
SQLite local database
Repository pattern for local data access
Sync service for server synchronization
Conflict resolution strategies (last-write-wins, merge, etc.)
Connectivity detection and sync on restore
Platform Features:
Push notifications (APNs for iOS, FCM for Android)
Biometric authentication (Face ID/Touch ID, Fingerprint)
Camera access (photo capture and selection)
Location services (current location, tracking)
File system operations (read/write, picker, sharing)

Technical Approach:

Use Built-in Frameworks: Continue using built-in frameworks (ILogger, IStringLocalizer, Shell navigation, SecureStorage)
Platform APIs Directly: Use MAUI platform APIs directly for platform features (no unnecessary abstractions)
ConnectSoft.Extensions.*: Leverage ConnectSoft.Extensions.* libraries for enhancements
ConnectSoft.Maui.UIKit: Integrate UIKit library for consistent UI components
Template Composition: Follow ConnectSoft template metadata composition patterns

Template Metadata Extension:

The full-featured template extends the base template.json using maui.template.extend.json: - identityOverrides: Override template name, description, tags - symbolAdds: Add full-featured parameters (UseApiIntegration, UseAuthentication, UseOfflineSupport, etc.) - postActionsAdds: Add post-actions for API configuration, authentication setup, etc.

CI/CD Requirements:

Main Pipeline: Build, test, publish results
iOS Build Pipeline: Build iOS app on macOS agents, code signing
Android Build Pipeline: Build Android app, code signing
Template Packaging Pipeline: Package template, publish to feed
Documentation Pipeline: Generate and publish documentation

Documentation Integration:

Update all three documentation repositories: - ConnectSoft.Documentation: Update templates.md, templates-dependencies.md - ConnectSoft.AI.SoftwareFactory.Documentation: Create mobile template documentation pages - ConnectSoft.CompanyDocumentation: Update template architecture docs if needed

Success Criteria:

Full-featured template generates working MAUI applications
All features (API, auth, offline, platform) work correctly
Template tested on both iOS and Android
Template metadata composition works correctly
CI/CD pipelines execute successfully
Documentation complete and published
All documentation repositories updated
Template follows ConnectSoft standards

Risks and Mitigations:

Risk: Platform feature complexity and platform-specific differences
Mitigation: Test on both platforms early, document platform-specific requirements
Risk: Offline sync complexity and conflict resolution
Mitigation: Start with simple sync strategies, document conflict resolution patterns
Risk: Template composition complexity
Mitigation: Follow proven ConnectSoft.BaseTemplate patterns, comprehensive testing

Dependencies:

Base template (Epic 1) - Must be complete
UIKit library (Epic 2) - Should be available for integration
ConnectSoft.Extensions.* libraries
.NET MAUI 9.0 SDK

Definition of Done: - Full-featured template repository created with base template as submodule - Application features implemented (Views, ViewModels, Shell navigation) - API integration implemented (Refit clients, retry policies, error handling) - Authentication implemented (MSAL, OAuth2, token management) - Offline support implemented (SQLite, local database, sync service) - Platform features implemented (push notifications, biometric auth, camera, location) - Comprehensive testing (unit tests, integration tests, UI tests) - Template metadata configured (maui.template.extend.json) - CI/CD pipelines created (iOS build, Android build, template packaging) - Full template documentation complete - All documentation repositories updated with mobile template information - Template tested on both iOS and Android - Code coverage meets minimum threshold (80%) - All features work correctly in generated applications

Tags: connectsoft, maui, full-template, api-integration, authentication, offline, platform-features, documentation, template-composition, submodule

Estimated Duration: 8-10 weeks

Feature 12: MAUI-FEAT-012 - Full Template Repository & Foundation¶

Description:

Create the full-featured template repository (ConnectSoft.MauiTemplate) with base template as Git submodule and solution structure. This feature establishes the foundation for the production-ready MAUI application template that will be used by developers to create new mobile applications. The template follows ConnectSoft template layering patterns, using the base template as a Git submodule for build-time extension.

Scope:

This feature includes: - Repository creation with proper folder structure - Git submodule configuration for base template inclusion - Template project structure (src/, tests/, docs/, etc.) - Template metadata files (template.json, template.extend.json) - Build configuration (Directory.Build.props, Directory.Packages.props) - CI/CD pipeline foundation (Azure DevOps YAML) - README.md with template overview

Technical Approach:

Reference ConnectSoft.BaseTemplate structure for consistency
Use Git submodule for base template (build-time extension)
Use template overlays for generation-time extension
Configure template metadata for dotnet new command
Set up build configuration for iOS and Android targets
Configure analyzers and code quality from the start

Repository Structure:

ConnectSoft.MauiTemplate/
├── base-template/                    # Git submodule to ConnectSoft.MauiBaseTemplate
├── src/
│   └── MauiApp.Application/          # Full-featured application project
├── tests/
│   ├── MauiApp.UnitTests/
│   ├── MauiApp.IntegrationTests/
│   └── MauiApp.UITests/
├── docs/
├── .template.config/
│   ├── template.json
│   └── template.extend.json
├── .azuredevops/
│   └── pipelines/
│       └── build-template.yml
├── Directory.Build.props
├── Directory.Packages.props
└── README.md

Template Metadata:

template.json: Template metadata, parameters, symbols
template.extend.json: Extensions/overrides if extending base template
Parameters: ProjectName, OrganizationName, etc.

Success Criteria:

Repository structure matches ConnectSoft standards
Git submodule configured correctly
Template metadata configured correctly
Solution builds cleanly
Template can be installed via dotnet new --install
README.md with template overview
Build configuration complete
CI/CD pipeline foundation ready

Tags: repository, full-template, submodule, foundation, template-metadata, solution-structure

Task: MAUI-TASK-022¶

Title: Create ConnectSoft.MauiTemplate repository, add base template as Git submodule, and set up solution structure

Description: Initialize the full-featured MAUI template repository. Add the base template as a Git submodule and set up the solution structure following ConnectSoft template layering patterns.

Repository: ConnectSoft.MauiTemplate

Acceptance Criteria: - Repository created with proper structure: - base-template/ - Git submodule pointing to ConnectSoft.MauiBaseTemplate - src/MauiApp.Application/ - Full-featured application project - src/MauiApp.Domain/ - Domain logic (if needed) - src/MauiApp.Infrastructure/ - Infrastructure implementations - tests/MauiApp.UnitTests/ - Unit tests - tests/MauiApp.IntegrationTests/ - Integration tests - tests/MauiApp.UITests/ - UI tests - docs/ - Documentation - .template.config/ - Template metadata - Git submodule configured: - base-template submodule added - .gitmodules file configured - Solution structure: - Solution includes base template projects - Solution includes full-featured projects - All project references configured - Solution builds successfully: - All projects build - No circular dependencies - Documentation added: - Repository structure explained - Submodule usage documented

Implementation Notes: - Follow ConnectSoft template layering patterns - Reference ConnectSoft.MicroserviceTemplate submodule structure - Use Git submodule for base template inclusion - Configure solution to include both base and full-featured projects - Document submodule initialization process - Reference template-architecture-specification.md

Dependencies: MAUI-TASK-013 (Base template must be complete)

Estimated Effort: 2 days

Tags: repository, submodule, solution-structure

Description:

Implement MVVM architecture with CommunityToolkit.Mvvm, navigation using MAUI Shell, and base ViewModels. This feature establishes the architectural foundation for the template, ensuring clean separation of concerns, testability, and maintainability. The navigation system uses MAUI Shell for declarative routing and deep linking support.

Scope:

This feature includes: - MVVM Setup: CommunityToolkit.Mvvm package integration, BaseViewModel class - Navigation: MAUI Shell configuration with routes, navigation service wrapper - Base ViewModels: BaseViewModel with common functionality (INotifyPropertyChanged, commands, navigation) - Dependency Injection: Service registration for ViewModels, navigation, services - Page Structure: Base page structure with ViewModel binding - Example Pages: Login, Home, Details, Settings pages as examples

MVVM Architecture:

BaseViewModel: - Inherits from ObservableObject (CommunityToolkit.Mvvm) - Implements common properties (IsBusy, Title, etc.) - Provides command helpers - Integrates with ILogger for logging - Integrates with IStringLocalizer for localization

Navigation: - Uses MAUI Shell for declarative routing - Routes defined in AppShell.xaml - Deep linking support via route parameters - Navigation service wrapper for ViewModel navigation

Technical Implementation:

BaseViewModel:

public abstract class BaseViewModel : ObservableObject
{
    protected readonly ILogger<BaseViewModel> Logger;
    protected readonly IStringLocalizer<BaseViewModel> Localizer;

    private bool _isBusy;
    public bool IsBusy
    {
        get => _isBusy;
        set => SetProperty(ref _isBusy, value);
    }

    // Common commands, navigation helpers, etc.
}

Navigation Service:

public interface INavigationService
{
    Task NavigateToAsync(string route, IDictionary<string, object> parameters = null);
    Task GoBackAsync();
}

// Uses Shell.Current.GoToAsync internally

AppShell Configuration:

<Shell>
    <ShellContent Title="Home" Route="home" ContentTemplate="{DataTemplate views:HomePage}" />
    <ShellContent Title="Settings" Route="settings" ContentTemplate="{DataTemplate views:SettingsPage}" />
</Shell>

Success Criteria:

MVVM architecture implemented correctly
BaseViewModel provides common functionality
Navigation works with MAUI Shell
Deep linking works correctly
Dependency injection configured
ViewModels are testable
Navigation service works correctly
Example pages demonstrate patterns

Tags: application, views, viewmodels, navigation, mvvm, architecture, community-toolkit, deep-linking, dependency-injection

Task: MAUI-TASK-023¶

Title: Implement MauiApp.Application with Views, ViewModels, and Shell navigation structure

Description: Implement the full-featured application with Views, ViewModels following MVVM patterns, and Shell navigation structure. Create example pages and navigation flow.

Repository: ConnectSoft.MauiTemplate

Acceptance Criteria: - Application structure implemented: - Views created (LoginPage, HomePage, DetailsPage, etc.) - ViewModels created for each View - Shell navigation structure configured - MVVM patterns implemented: - ViewModels use BaseViewModel - Data binding configured - Commands implemented - Property change notifications working - Navigation implemented: - Shell routes registered - Navigation between pages works - Deep linking configured - Navigation parameters handled - Example pages implemented: - Login page - Home/Dashboard page - Details page - Settings page - Application runs successfully: - All pages render correctly - Navigation works - Data binding works - Documentation added: - Navigation patterns - MVVM patterns - View/ViewModel examples

Implementation Notes: - Use CommunityToolkit.Mvvm for MVVM helpers - Follow MVVM best practices - Use Shell navigation directly (no abstraction) - Create example pages showing common patterns - Reference ConnectSoft.Blazor.ShellTemplate patterns - Document navigation and MVVM patterns

Dependencies: MAUI-TASK-022

Estimated Effort: 4 days

Tags: application, mvvm, navigation, views

Feature 14: MAUI-FEAT-014 - API Integration & Authentication¶

Description:

Implement API integration with Refit clients, retry policies, error handling, and authentication with MSAL/OAuth2. This feature provides a complete API integration layer with OAuth2 authentication, automatic token refresh, and secure token storage. The implementation uses Polly for resilience patterns (retry, circuit breaker) and integrates with the logging and observability infrastructure.

Scope:

This feature includes: - API Client: Refit-based REST API client with interface definitions - Authentication: Microsoft.Identity.Client (MSAL) for OAuth2 flows - Token Management: Automatic token refresh, token storage in SecureStorage - Resilience: Polly policies for retry, circuit breaker, timeout - HTTP Configuration: HttpClient configuration with Polly, logging, telemetry - Authentication Service: Service for login, logout, token refresh

API Client Implementation:

Refit Interface:

public interface IApiClient
{
    [Get("/api/users")]
    Task<List<User>> GetUsersAsync();

    [Post("/api/users")]
    Task<User> CreateUserAsync([Body] User user);
}

HTTP Client Configuration: - Uses IHttpClientFactory for HttpClient creation - Polly policies: Retry (exponential backoff), Circuit Breaker, Timeout - Automatic token injection via DelegatingHandler - Logging via ILogger - Telemetry via observability extensions

Authentication Flow:

Login: User authenticates via MSAL (Interactive or Silent)
Token Storage: Access token and refresh token stored in SecureStorage
API Calls: Token automatically injected into Authorization header
Token Refresh: Automatic refresh when token expires
Logout: Clear tokens from SecureStorage

MSAL Configuration:

public class AuthenticationService : IAuthenticationService
{
    private readonly IPublicClientApplication _pca;

    public async Task<AuthenticationResult> LoginAsync()
    {
        // MSAL interactive login
    }

    public async Task<string> GetAccessTokenAsync()
    {
        // Get token from cache or refresh
    }
}

Secure Storage:

Uses MAUI SecureStorage for token storage
Keys: "access_token", "refresh_token", "id_token"
Automatic encryption/decryption by platform

Resilience Patterns:

Retry Policy: Exponential backoff for transient failures
Circuit Breaker: Open circuit after N failures
Timeout: Request timeout configuration
Fallback: Optional fallback responses

Success Criteria:

API client works with Refit interfaces
Authentication flow works (login, logout, token refresh)
Tokens stored securely in SecureStorage
Automatic token injection in API calls
Polly resilience policies configured
HTTP requests logged and traced
Error handling for authentication failures
Token refresh works automatically

Tags: api-integration, authentication, refit, msal, oauth2, http-clients, polly, resilience, secure-storage, token-management

Task: MAUI-TASK-024¶

Title: Implement API integration with Refit clients, retry policies, error handling, and token refresh

Description: Implement API integration using Refit for REST API clients. Configure retry policies with Polly, implement error handling, and set up automatic token refresh.

Repository: ConnectSoft.MauiTemplate

Acceptance Criteria: - Refit clients implemented: - API client interfaces defined - Refit clients registered in DI - API endpoints configured - Retry policies configured: - Polly retry policies set up - Exponential backoff configured - Circuit breaker configured (if applicable) - Error handling implemented: - Global error handler - API error models - Error display in UI - Token refresh implemented: - Automatic token refresh on 401 - Token storage in SecureStorage - Refresh token handling - API integration examples: - Example API client - Example API usage in ViewModel - Documentation added: - API integration patterns - Error handling patterns - Retry policy configuration

Implementation Notes: - Use Refit for API client generation - Use Polly for retry and resilience policies - Use Microsoft.Extensions.Http.Polly for HTTP client policies - Implement global error handling - Store tokens in SecureStorage - Reference ConnectSoft.BaseTemplate API patterns - Document API integration best practices

Dependencies: MAUI-TASK-023

Estimated Effort: 5 days

Tags: api-integration, refit, polly, error-handling

Task: MAUI-TASK-025¶

Title: Implement authentication with MSAL, OAuth2 flows, SecureStorage for tokens, and automatic refresh

Description: Implement authentication using Microsoft Identity Client (MSAL) for OAuth2 flows. Handle token storage in SecureStorage, implement automatic token refresh, and provide authentication state management.

Repository: ConnectSoft.MauiTemplate

Acceptance Criteria: - MSAL configured: - Microsoft.Identity.Client package integrated - Authentication configuration - OAuth2 flows implemented - Token management: - Tokens stored in SecureStorage - Token refresh implemented - Token expiration handling - Authentication state: - Authentication state management - Login/logout flows - Protected routes - Authentication UI: - Login page - Logout functionality - User profile display - Authentication works: - Login flow works - Token refresh works - Logout works - Protected routes work - Documentation added: - Authentication setup guide - OAuth2 configuration - Token management patterns

Implementation Notes: - Use Microsoft.Identity.Client (MSAL) for authentication - Configure OAuth2 providers (Azure AD, Google, etc.) - Store tokens securely in SecureStorage - Implement automatic token refresh - Handle authentication state changes - Reference MSAL documentation - Document authentication setup and configuration

Dependencies: MAUI-TASK-024

Estimated Effort: 5 days

Tags: authentication, msal, oauth2, secure-storage

Feature 15: MAUI-FEAT-015 - Offline Support & Platform Features¶

Description:

Implement offline support with SQLite, local database, sync service, and platform-specific features (push notifications, biometric auth, camera, location). This feature enables the application to work offline, store data locally, and synchronize with the backend when connectivity is restored. Additionally, it integrates with native platform capabilities (iOS and Android) to provide rich mobile experiences.

Scope:

This feature includes: - SQLite Database: Entity Framework Core with SQLite provider - Local Data Models: Entity models for local storage - Repository Pattern: Repository abstraction for data access - Offline-First: Application works without network connectivity - Sync Service: Background sync service for data synchronization - Conflict Resolution: Strategies for handling sync conflicts - Connectivity Detection: Network connectivity monitoring - Push Notifications: APNs (iOS) and FCM (Android) integration - Biometric Authentication: Face ID, Touch ID, Fingerprint authentication - Camera: Photo capture, image picker - Location: GPS location services, geofencing - File System: File picker, file save, file sharing - Permissions: Runtime permission requests for all platform features

Offline-First Architecture:

Local-First: All data operations work against local SQLite database
Background Sync: Sync service runs in background to sync with backend
Optimistic UI: UI updates immediately, sync happens in background
Conflict Resolution: Last-write-wins or custom resolution strategies

SQLite Setup:

public class AppDbContext : DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<Order> Orders { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var dbPath = Path.Combine(FileSystem.AppDataDirectory, "app.db");
        optionsBuilder.UseSqlite($"Data Source={dbPath}");
    }
}

Repository Pattern:

public interface IRepository<T> where T : class
{
    Task<List<T>> GetAllAsync();
    Task<T> GetByIdAsync(int id);
    Task<T> AddAsync(T entity);
    Task UpdateAsync(T entity);
    Task DeleteAsync(int id);
}

Sync Service:

Sync Strategy: Pull changes from backend, merge with local data
Conflict Resolution: Last-write-wins, manual resolution, or custom strategy
Sync Triggers: On app start, on connectivity restored, periodic, manual
Sync Status: Track sync state, last sync time, sync errors

Connectivity Detection:

Uses Connectivity.NetworkAccess to detect network availability
Monitor connectivity changes
Trigger sync when connectivity restored
Show connectivity status in UI

Platform Features:

Push Notifications: APNs (iOS), FCM (Android) with permission handling
Biometric Auth: Face ID, Touch ID, Fingerprint using platform APIs
Camera: Photo capture using MediaPicker
Location: GPS services using Geolocation
File System: File picker and sharing using FilePicker

Success Criteria:

SQLite database configured and working
Local data operations work offline
Repository pattern implemented
Sync service syncs data with backend
Conflict resolution works correctly
Connectivity detection works
Push notifications work on iOS and Android
Biometric authentication works
Camera, location, and file system features work
Permissions requested and handled correctly
All platform features tested on real devices

Tags: offline, sqlite, sync, platform-features, push-notifications, biometric, camera, location, file-system, entity-framework-core, repository-pattern, conflict-resolution, connectivity, permissions

Task: MAUI-TASK-026¶

Title: Implement offline support with SQLite, local database, sync service, and conflict resolution

Description: Implement offline support using SQLite for local data storage. Create local database schema, implement sync service for data synchronization, and handle conflict resolution.

Repository: ConnectSoft.MauiTemplate

Acceptance Criteria: - SQLite configured: - SQLite database created - Entity models defined - Database migrations configured - Local database implemented: - Repository pattern for local data - CRUD operations - Query support - Sync service implemented: - Data synchronization logic - Conflict detection - Conflict resolution strategies - Offline mode support: - App works offline - Data cached locally - Sync on connectivity restore - Documentation added: - Offline support patterns - Sync service usage - Conflict resolution strategies

Implementation Notes: - Use sqlite-net-pcl or Microsoft.Data.Sqlite - Implement repository pattern for local data access - Create sync service for server synchronization - Handle conflict resolution (last-write-wins, merge, etc.) - Test offline scenarios thoroughly - Document offline support patterns

Dependencies: MAUI-TASK-025

Estimated Effort: 6 days

Tags: offline, sqlite, sync, conflict-resolution

Task: MAUI-TASK-027¶

Title: Implement platform features (push notifications, biometric auth, camera, location, file system) using platform APIs directly

Description: Implement platform-specific features using MAUI platform APIs directly. Add push notifications, biometric authentication, camera access, location services, and file system operations.

Repository: ConnectSoft.MauiTemplate

Acceptance Criteria: - Push notifications implemented: - iOS: APNs integration - Android: FCM integration - Notification handling - Biometric authentication implemented: - Face ID / Touch ID (iOS) - Fingerprint (Android) - Biometric authentication flow - Camera access implemented: - Camera permission handling - Photo capture - Photo selection - Location services implemented: - Location permission handling - Current location - Location tracking - File system operations: - File reading/writing - File picker - File sharing - Platform features work: - All features tested on iOS - All features tested on Android - Documentation added: - Platform feature setup - Permission handling - Usage examples

Implementation Notes: - Use MAUI platform APIs directly (no custom abstractions) - Use CommunityToolkit.Maui for permissions if needed - Handle platform-specific differences - Implement proper permission requests - Test on both iOS and Android - Document platform-specific setup requirements - Reference MAUI platform feature documentation

Dependencies: MAUI-TASK-026

Estimated Effort: 8 days

Tags: platform-features, push-notifications, biometric, camera, location

Feature 16: MAUI-FEAT-016 - Full Template Testing & CI/CD¶

Description:

Create comprehensive testing infrastructure and CI/CD pipelines for the full-featured template. This feature ensures the template is well-tested, can be built and packaged automatically, and follows ConnectSoft CI/CD standards. The testing infrastructure includes unit tests, integration tests, and UI tests, while the CI/CD pipeline handles building, testing, packaging, and publishing the template.

Scope:

This feature includes: - Unit Tests: Tests for ViewModels, services, repositories, utilities - Integration Tests: API integration tests, database integration tests, authentication integration tests - UI Tests: Page navigation tests, user interaction tests, platform feature tests - Test Infrastructure: Test base classes, test helpers, mock setup - CI/CD Pipeline: Azure DevOps pipeline for building, testing, packaging, publishing - Template Packaging: Template packaging for dotnet new command - Documentation: Test patterns, CI/CD documentation

Testing Requirements:

Unit Tests: Test component behavior, state changes, interactions
Integration Tests: Test API integration, database operations, authentication flows
UI Tests: Test page navigation, user interactions, platform features
Test Coverage: Minimum 80% code coverage for application code
Test Infrastructure: Component test base classes, API test helpers, UI test framework

CI/CD Pipeline:

Build: Build solution for iOS and Android
Test: Run all test suites (unit, integration, UI)
Package: Package template as NuGet package
Publish: Publish template to NuGet feed
Artifacts: Store build artifacts for distribution

Template Packaging:

Template metadata (template.json, template.extend.json)
Template files and structure
NuGet package configuration
Template installation via dotnet new --install

Success Criteria:

Unit tests created with 80%+ coverage
Integration tests created and passing
UI tests created and passing
Test infrastructure complete
CI/CD pipeline builds successfully
CI/CD pipeline runs all tests
Template packages correctly
Template can be installed via dotnet new
Documentation complete

Tags: testing, cicd, ui-tests, azure-devops, unit-tests, integration-tests, template-packaging, nuget

Task: MAUI-TASK-028¶

Title: Create test projects (UnitTests, IntegrationTests, UITests) with comprehensive test coverage

Description: Create comprehensive test suite including unit tests, integration tests, and UI tests. Ensure high test coverage and test quality.

Repository: ConnectSoft.MauiTemplate

Acceptance Criteria: - Unit tests created: - ViewModel tests - Service tests - Repository tests - High code coverage (minimum 80%) - Integration tests created: - API integration tests - Database integration tests - Authentication integration tests - UI tests created: - Page navigation tests - User interaction tests - Platform feature tests - Test infrastructure: - Test base classes - Test helpers - Mock setup - Tests run successfully: - All tests pass - Tests run in CI/CD - Documentation added: - Test patterns - How to add new tests

Implementation Notes: - Use MSTest or xUnit - Use Moq or NSubstitute for mocking - Use FluentAssertions for assertions - Create UI test framework (Appium, MAUI UITest, etc.) - Set up test infrastructure - Reference ConnectSoft.BaseTemplate test patterns - Document test patterns and conventions

Dependencies: MAUI-TASK-027

Estimated Effort: 5 days

Tags: testing, unit-tests, integration-tests, ui-tests

Task: MAUI-TASK-029¶

Title: Create template/maui.template.extend.json to extend base template.json with full-featured parameters

Description: Create template extend file that extends the base template.json with full-featured template parameters. Configure template metadata following ConnectSoft template composition patterns.

Repository: ConnectSoft.MauiTemplate

Acceptance Criteria: - maui.template.extend.json created: - Extends base template.json - Adds full-featured parameters - Configures post-actions - Template parameters include: - UseApiIntegration (bool) - UseAuthentication (bool) - UseOfflineSupport (bool) - UsePushNotifications (bool) - UseBiometricAuth (bool) - ApiBaseUrl (string) - AuthenticationProvider (choice) - Post-actions configured: - Additional setup steps - Configuration file updates - Template composition works: - Base + Full template merges correctly - All parameters available - Post-actions execute - Documentation added: - Template parameter reference - How to use the template

Implementation Notes: - Follow ConnectSoft template metadata composition patterns - Reference template-metadata-composition.md - Use extend file format (identityOverrides, symbolAdds, etc.) - Test template generation end-to-end - Document all template parameters

Dependencies: MAUI-TASK-027

Estimated Effort: 2 days

Tags: template-metadata, extend-file, parameters

Task: MAUI-TASK-030¶

Title: Create Azure DevOps pipelines (main, iOS build, Android build, template packaging, documentation)

Description: Create comprehensive Azure DevOps pipelines for building, testing, and packaging the full-featured template. Include iOS and Android specific build pipelines.

Repository: ConnectSoft.MauiTemplate

Acceptance Criteria: - Main pipeline created: - Builds solution - Runs unit tests - Runs integration tests - Publishes test results - iOS build pipeline created: - Builds iOS app - Runs iOS tests - Creates iOS artifacts - Android build pipeline created: - Builds Android app - Runs Android tests - Creates Android artifacts - Template packaging pipeline: - Packages template - Publishes to feed - Documentation pipeline: - Generates documentation - Publishes to site - All pipelines configured: - Proper triggers - Quality gates - Artifact publishing - Documentation added: - Pipeline configuration - Build requirements

Implementation Notes: - Use macOS agents for iOS builds - Use Windows/Linux agents for Android builds - Configure code signing for iOS and Android - Set up test result publishing - Configure artifact publishing - Reference ConnectSoft.BaseTemplate pipelines - Document build requirements and setup

Dependencies: MAUI-TASK-029

Estimated Effort: 4 days

Tags: cicd, azure-devops, ios-build, android-build

Feature 17: MAUI-FEAT-017 - Full Template Documentation¶

Description:

Create comprehensive documentation for the full-featured template. This feature ensures developers have complete, clear, and actionable documentation for using the template, understanding its architecture, integrating APIs, implementing offline support, using platform features, and deploying applications. The documentation follows ConnectSoft standards and includes both developer guides and AI coding agent references.

Scope:

This feature includes: - Template Overview: High-level template description, architecture, features, quick start - API Integration Guide: How to integrate with REST APIs, authentication, error handling - Offline Support Guide: SQLite setup, sync service usage, conflict resolution - Platform Features Guide: Push notifications, biometric auth, camera, location, file system - Deployment Guide: Building for iOS and Android, app store submission, CI/CD - AGENTS.md: AI coding agent reference with template structure, patterns, conventions - MkDocs Configuration: Navigation structure, theme, plugins

Documentation Structure:

maui-overview.md: Template overview, architecture, features, quick start guide
api-integration.md: API client setup, authentication, error handling, retry policies
offline-support.md: SQLite configuration, repository pattern, sync service, conflict resolution
platform-features.md: Push notifications, biometric auth, camera, location, file system, permissions
deployment.md: Build configuration, app store submission, CI/CD setup, troubleshooting
AGENTS.md: Template structure, patterns, conventions, code generation guidelines

Documentation Requirements:

Completeness: All features documented with examples
Clarity: Clear explanations, step-by-step guides
Code Examples: Working code examples for all features
Best Practices: Recommended patterns and practices
Troubleshooting: Common issues and solutions
Diagrams: Architecture diagrams, flow diagrams (Mermaid)
AI Agent Support: AGENTS.md for AI coding agents

MkDocs Configuration:

Navigation structure with all documentation pages
MkDocs Material theme
Search functionality
Code highlighting
Mermaid diagram support

Success Criteria:

All documentation files created
Documentation is comprehensive and clear
Code examples work correctly
Diagrams render correctly
MkDocs site generates successfully
AGENTS.md provides complete reference
Documentation follows ConnectSoft standards
All links work correctly

Tags: documentation, full-template, guides, mkdocs, ai-agents, api-integration, offline-support, platform-features, deployment

Task: MAUI-TASK-031¶

Title: Create documentation (maui-overview.md, api-integration.md, offline-support.md, platform-features.md, deployment.md, AGENTS.md) and configure mkdocs.yml

Description: Create comprehensive documentation for the full-featured template including overview, feature guides, deployment guide, and AGENTS.md for AI coding agents.

Repository: ConnectSoft.MauiTemplate

Acceptance Criteria: - Documentation files created: - docs/maui-overview.md - Template overview - docs/api-integration.md - API integration guide - docs/offline-support.md - Offline support guide - docs/platform-features.md - Platform features guide - docs/deployment.md - Deployment guide - AGENTS.md - AI coding agent reference - Documentation includes: - Feature descriptions - Code examples - Configuration guides - Best practices - Troubleshooting - mkdocs.yml configured: - Navigation structure - Theme and plugins - Documentation site generates: - All links work - Diagrams render - Documentation quality: - Clear and comprehensive - Examples work - Follows ConnectSoft standards

Implementation Notes: - Reference ConnectSoft.BaseTemplate AGENTS.md - Use Mermaid diagrams - Include code examples - Document all features - Follow ConnectSoft documentation standards - Use MkDocs Material theme

Dependencies: MAUI-TASK-030

Estimated Effort: 4 days

Tags: documentation, mkdocs, guides

Feature 18: MAUI-FEAT-018 - Documentation Repository Updates¶

Description:

Update all three documentation repositories (ConnectSoft.Documentation, ConnectSoft.AI.SoftwareFactory.Documentation, ConnectSoft.CompanyDocumentation) with mobile template information. This feature ensures the MAUI mobile templates are properly documented and integrated into the ConnectSoft documentation ecosystem, making them discoverable and understandable for developers and AI coding agents.

Scope:

This feature includes: - ConnectSoft.Documentation Updates: Template overview, dependency diagrams, feature matrices - ConnectSoft.AI.SoftwareFactory.Documentation Updates: Template-specific documentation, navigation updates - ConnectSoft.CompanyDocumentation Updates: Template architecture documentation, if needed - Consistency: Ensure all repositories have consistent information about mobile templates

ConnectSoft.Documentation Updates:

templates.md: Add mobile templates to template overview
templates-dependencies.md: Add mobile templates to dependency diagrams, feature matrices
Template Architecture Docs: Update if mobile templates affect architecture patterns

ConnectSoft.AI.SoftwareFactory.Documentation Updates:

templates-overview.md: Add mobile templates section
base-template.md: Reference mobile templates as derived templates
New Documentation Pages: Create mobile template-specific documentation pages (maui-base-template.md, maui-template.md)
mkdocs.yml: Add mobile template navigation items

ConnectSoft.CompanyDocumentation Updates:

Template Architecture Docs: Update if mobile templates affect company-wide architecture patterns
Mobile Template Information: Add mobile template information where relevant

Documentation Integration:

Dependency Diagrams: Add mobile templates to Mermaid diagrams showing template relationships
Feature Matrices: Add mobile templates to feature comparison tables
Navigation: Add mobile templates to documentation navigation structures
Cross-References: Add links between related documentation pages

Success Criteria:

All three documentation repositories updated
Mobile templates appear in template overviews
Dependency diagrams include mobile templates
Feature matrices include mobile templates
Navigation structures updated
All links work correctly
Documentation is consistent across repositories
Documentation follows existing patterns and standards

Tags: documentation, templates, integration, repositories, dependency-diagrams, feature-matrices, navigation

Task: MAUI-TASK-032¶

Title: Update all three documentation repositories (ConnectSoft.Documentation, ConnectSoft.AI.SoftwareFactory.Documentation, ConnectSoft.CompanyDocumentation) with mobile template information

Description: Update all documentation repositories to include information about the MAUI mobile templates. Add mobile templates to template overviews, dependency diagrams, and feature matrices.

Repositories: - ConnectSoft.Documentation - ConnectSoft.AI.SoftwareFactory.Documentation - ConnectSoft.CompanyDocumentation

Acceptance Criteria: - ConnectSoft.Documentation updated: - templates.md updated with mobile templates - templates-dependencies.md updated with mobile templates in diagrams - templates-dependencies.md updated with mobile templates in feature matrix - Template architecture docs updated (if needed) - ConnectSoft.AI.SoftwareFactory.Documentation updated: - templates-overview.md updated with mobile templates - base-template.md updated to reference mobile templates - New mobile template documentation pages created - mkdocs.yml updated with mobile template navigation - ConnectSoft.CompanyDocumentation updated: - Template architecture docs updated (if needed) - Mobile template information added - All documentation: - Links work correctly - Diagrams updated - Consistent with existing patterns - Documentation reviewed: - All updates reviewed - Consistency checked - Quality verified

Implementation Notes: - Follow existing documentation patterns - Update template dependency diagrams - Add mobile templates to feature matrices - Create new documentation pages following existing structure - Update navigation in mkdocs.yml files - Reference template-architecture-specification.md - Ensure consistency across all three repositories

Dependencies: MAUI-TASK-031

Estimated Effort: 3 days

Tags: documentation, templates, integration, repositories

Summary¶

This backlog plan organizes the MAUI mobile template development into three major epics:

Epic 1: Base MAUI Template Foundation - Core infrastructure and cross-cutting concerns (6-8 weeks)
Epic 2: MAUI UIKit Library - Reusable UI component library (6-8 weeks)
Epic 3: Full-Featured Template & Integration - Production-ready template and documentation (8-10 weeks)

Total Estimated Duration: 20-26 weeks (5-6.5 months)

Key Principles: - Use built-in .NET/MAUI frameworks (ILogger, IStringLocalizer, Shell navigation, SecureStorage, Preferences) - Minimal abstractions - only for testability when necessary - Leverage ConnectSoft.Extensions.* libraries for enhancements - Follow ConnectSoft template layering and composition patterns - Comprehensive testing and documentation - Full CI/CD pipeline support

MAUI Mobile Template Epic Breakdown - High-level epic breakdown
MAUI Mobile Template Developer Guide - Developer preparation guide
MAUI Mobile Template Future Enhancements - Future enhancements and missing functionality plan
Template Architecture Specification
Template Layering and Reuse
Template Metadata Composition
Templates Dependencies
Templates Overview

MAUI Mobile Template - Development Backlog Plan¶

Overview¶

Work Item Structure¶

ID Naming Convention¶

Epic 1: MAUI-EPIC-001 - Base MAUI Template Foundation¶

Feature 1: MAUI-FEAT-001 - Repository & Solution Structure¶

Task: MAUI-TASK-001¶

Task: MAUI-TASK-002¶

Feature 2: MAUI-FEAT-002 - Core Infrastructure¶

Task: MAUI-TASK-003¶

Task: MAUI-TASK-004¶

Task: MAUI-TASK-005¶

Feature 3: MAUI-FEAT-003 - Cross-Cutting Concerns¶

Task: MAUI-TASK-006¶

Task: MAUI-TASK-007¶

Task: MAUI-TASK-008¶

Task: MAUI-TASK-009¶

Feature 4: MAUI-FEAT-004 - Testing Infrastructure¶

Task: MAUI-TASK-010¶

Feature 5: MAUI-FEAT-005 - Template Metadata & CI/CD¶

Task: MAUI-TASK-011¶

Task: MAUI-TASK-012¶

Feature 6: MAUI-FEAT-006 - Base Template Documentation¶

Task: MAUI-TASK-013¶

Epic 2: MAUI-EPIC-002 - MAUI UIKit Library¶

Feature 7: MAUI-FEAT-007 - UIKit Repository & Foundation¶

Task: MAUI-TASK-014¶

Feature 8: MAUI-FEAT-008 - Core UI Components¶

Task: MAUI-TASK-015¶

Feature 9: MAUI-FEAT-009 - Design Tokens & Theming¶

Task: MAUI-TASK-016¶

Feature 10: MAUI-FEAT-010 - Localization & Accessibility¶

Task: MAUI-TASK-017¶

Task: MAUI-TASK-018¶

Feature 11: MAUI-FEAT-011 - UIKit Testing & Documentation¶

Task: MAUI-TASK-019¶

Task: MAUI-TASK-020¶

Task: MAUI-TASK-021¶

Epic 3: MAUI-EPIC-003 - Full-Featured Template & Integration¶

Feature 12: MAUI-FEAT-012 - Full Template Repository & Foundation¶

Task: MAUI-TASK-022¶

Feature 13: MAUI-FEAT-013 - MVVM Architecture & Navigation¶

Task: MAUI-TASK-023¶

Feature 14: MAUI-FEAT-014 - API Integration & Authentication¶

Task: MAUI-TASK-024¶

Task: MAUI-TASK-025¶

Feature 15: MAUI-FEAT-015 - Offline Support & Platform Features¶

Task: MAUI-TASK-026¶

Task: MAUI-TASK-027¶

Feature 16: MAUI-FEAT-016 - Full Template Testing & CI/CD¶

Task: MAUI-TASK-028¶

Task: MAUI-TASK-029¶

Task: MAUI-TASK-030¶

Feature 17: MAUI-FEAT-017 - Full Template Documentation¶

Task: MAUI-TASK-031¶

Feature 18: MAUI-FEAT-018 - Documentation Repository Updates¶

Task: MAUI-TASK-032¶

Summary¶

Related Documents¶