How ninashine/programmation-mobile works
Main Components
• Overall Repository: Emphasize that the repository contains multiple independent Android app projects – each is a separate module (e.g., TP1 – an Agenda or event app; TP2 – sensor and hardware interaction app; Train – a ticket and payment/booking app; TP3 – an app with user accounts and local database using Room; TP2_suite and TP3_suite – extended or suite versions).
• For each project/app:
– Presentation Layer: Activities (e.g., MainActivity, AddEventActivity, etc.), fragments (in TP3, TP3_suite) and UI components (XML layouts, theme definitions).
– Business/Logic Layer: The Kotlin/Java classes handling control flow (Adapters, Services like SNCFService, and other handler classes).
– Data Layer: In some modules (e.g., in TP3 with its database package containing PlanningDao, UserDao, and UserDatabase) components related to data storage and retrieval.
– Testing Layer: Unit tests and instrumented tests are present in each app module.
– Build & Configuration: Gradle scripts, properties files, Proguard rules, and dependency configurations.
Relationships and Interactions
• Within each mobile application, illustrate the separation between the UI (Activities, Fragments, Adapters), the underlying business logic/services (for instance, handling sensor events in TP2 or calling external APIs in the Train project), and the data storage components.
• How UI actions (e.g., button clicks in an Activity) trigger business operations that may then query a local database (TP3) or communicate with external services (as seen in the Train project with SNCFService).
Important Architectural Patterns and Design Principles
• Standard Android Architecture: All projects follow Android Studio’s typical project structure (activity, layout, resource separation).
• Modularization: Each TP project is modular – it is its own Gradle module with independent build configurations and testing suites.
• Testing Inclusion: Note the presence of both unit tests and instrumented tests which are part of the quality assurance flow.
Relevant Technologies, Frameworks, and Tools
• Android Studio is the IDE used, and Gradle is the build tool; list these components.
• Kotlin (and/or Java) are used for application logic.
• The Android SDK is fundamental, with resources (XML layouts, theming, etc.) and standard libraries.
• For the TP3 projects, mention the usage of local databases (Room or SQLite via data access objects like UserDao).
• Testing frameworks (JUnit for unit tests, Espresso for instrumented tests) should be referenced as part of the testing components.
Instructing the Principal Software Engineer
• “TP1 - Agenda App”
. UI: MainActivity, AddEventActivity, EventsAdapter, XML layouts.
. Logic: Business operations tied to event management.
. Configuration: Gradle build, manifest file.
• “TP2 - Sensor App”
. UI: Sensor-related Activities (AccelerometerActivity, GeoLocationActivity, etc.).
. Logic: SensorAdapters and sensor handling code.
• “Train App”
. UI: MainActivity, PaymentActivity, ResultsActivity.
. Service Layer: SNCFService handling API calls.
• “TP3 - User & Planning App”
. UI: Login/Inscription screens, Planning screens.
. Data: Database (UserDatabase, PlanningDao) with model classes.
Detail and Clarity
• You do not need to overly subordinate every file, but capture the essential structure:
• The file tree shows that the structure exactly mirrors standard Android app architecture – so focus on the conceptual layers rather than every single directory.