Generate a prompt for a Google Login App with a Settings Layout [Change Language, Dark Mode, User Layout, Terms and Conditions, Disclaimer, Log Out] using an XML layout, the latest Material UI Design, in Kotlin in Android Studio. # AI DEVELOPMENT PROMPT — GOOGLE LOGIN APP WITH SETTINGS Create a complete, production-ready **Android application in Kotlin using Android Studio**, with **XML layouts** and the latest **Material Design / Material 3 UI** components. The app should implement a modern **Google Login authentication system** and a professional **Settings screen**. ## 1. Technology Requirements * Android Studio latest stable version * Kotlin * XML layouts — do NOT use Jetpack Compose * Material 3 / latest Material Components * Firebase Authentication * Google Sign-In / Google Identity authentication using the current recommended Firebase-compatible approach * AndroidX * ViewBinding * Gradle Kotlin DSL * Minimum SDK: 23 or higher * Target the latest stable Android SDK * Edge-to-edge support * Light and Dark themes * Proper handling of Android back navigation * Follow modern Android architecture and security practices Use clean, maintainable, modular Kotlin code. --- # 2. App Flow Create the following screens: ### Screen 1 — Login Activity Design a premium, simple Google Login screen. UI: * App logo/icon at the top * App name * Welcome heading: **"Welcome Back!"** * Subtitle: **"Sign in to continue"** * Large Material 3 Google Sign-In button * Loading indicator while authentication is processing * Error message area using Material components The login screen should have a clean **white/light background** in Light Mode. Use proper spacing, rounded corners, typography, and accessibility. When the user taps **Sign in with Google**: 1. Open Google authentication. 2. Allow the user to select a Google account. 3. Authenticate the user with Firebase Authentication. 4. Show a loading state. 5. Handle success and failure properly. 6. On successful authentication, open `MainActivity`. 7. Save/maintain the authenticated session. 8. Do not ask the user to log in again while a valid Firebase session exists. Do not store the user's Google password or sensitive authentication credentials locally. --- # 3. Main Activity After successful login, open a modern dashboard. Display: * User profile image * User display name * User email * Welcome message * Material 3 Top App Bar * Settings icon in the toolbar Example: **"Hello, [User Name]"** Tapping the Settings icon should open: `SettingsActivity` Use circular profile-image styling with proper fallback handling. --- # 4. Settings Activity Create a professional Material 3 Settings screen using XML. Title: **Settings** Use a `ScrollView` or `NestedScrollView` so the screen works correctly on smaller devices. Organize settings into logical sections. ## ACCOUNT ### User Layout Create a settings item showing: * User profile image * User name * User email * Account arrow icon When clicked, open a user-profile screen/dialog containing: * Profile photo * Name * Email * Google account information * Firebase UID if appropriate for an account/debug section * Back button Do not expose sensitive authentication information. --- # 5. APP PREFERENCES ### Change Language Create a clickable Material settings item: **Change Language** Subtitle: **English** When clicked, show a Material 3 dialog/bottom sheet containing language choices. Include: * English * Hindi Use radio buttons or another appropriate Material selection component. Save the selected language locally using `DataStore Preferences` or another modern persistent preference mechanism. When the language changes, update the application's displayed strings appropriately. Use Android string resources: * `values/strings.xml` * `values-hi/strings.xml` Do not hard-code UI strings inside Kotlin code. --- # 6. Dark Mode Create a settings row: **Dark Mode** Subtitle: **Use dark theme** Include a Material 3 `SwitchMaterial` / appropriate Material switch. Requirements: * OFF = Light Mode * ON = Dark Mode * Save the preference using DataStore * Restore the preference when the app starts * Apply the theme without crashing or recreating incorrectly * Respect modern Android theme behavior Create appropriate Light and Dark color resources. The Dark Mode design must remain readable and visually polished. --- # 7. TERMS AND CONDITIONS Create a clickable settings item: **Terms and Conditions** When clicked, open: `TermsActivity` Create a professional Terms and Conditions page containing sections such as: 1. Introduction 2. Acceptance of Terms 3. User Accounts 4. Google Authentication 5. User Responsibilities 6. Privacy and Data 7. Third-Party Services 8. Intellectual Property 9. Limitation of Liability 10. Changes to Terms 11. Contact Information Use XML and Material 3 components. The content should be easy to read with proper typography and spacing. Keep the legal text as editable placeholder content so it can later be replaced with the application's actual legal terms. --- # 8. DISCLAIMER Create a clickable settings item: **Disclaimer** When clicked, open: `DisclaimerActivity` Include sections such as: * General Information * Accuracy of Information * Third-Party Services * Google/Firebase Services * User Responsibility * Limitation of Liability * Changes to Disclaimer Clearly explain that the final disclaimer should be customized according to the actual application and business requirements. --- # 9. LOG OUT At the bottom of the Settings screen create a prominent: **Log Out** button. Use a Material 3 outlined or text button with an appropriate warning/error visual treatment. When tapped: 1. Display a confirmation dialog. 2. Message: **"Are you sure you want to log out?"** 3. Buttons: * Cancel * Log Out 4. If the user confirms: * Sign out from Firebase Authentication. * Sign out from the Google authentication provider if required by the selected authentication implementation. * Clear appropriate local session/preferences if necessary. * Navigate back to `LoginActivity`. * Clear the Activity back stack so the user cannot return to authenticated screens using the Back button. --- # 10. XML Layout Structure Use separate XML files for each screen. Suggested structure: ```text app/ └── src/ └── main/ ├── java/com/example/app/ │ ├── LoginActivity.kt │ ├── MainActivity.kt │ ├── SettingsActivity.kt │ ├── UserProfileActivity.kt │ ├── TermsActivity.kt │ ├── DisclaimerActivity.kt │ └── utils/ │ ├── ThemeManager.kt │ └── LanguageManager.kt │ ├── res/ │ ├── layout/ │ │ ├── activity_login.xml │ │ ├── activity_main.xml │ │ ├── activity_settings.xml │ │ ├── activity_user_profile.xml │ │ ├── activity_terms.xml │ │ └── activity_disclaimer.xml │ │ │ ├── drawable/ │ ├── mipmap/ │ ├── values/ │ │ ├── colors.xml │ │ ├── strings.xml │ │ └── themes.xml │ └── values-night/ │ └── themes.xml │ └── AndroidManifest.xml ``` Use `ViewBinding` instead of repeated `findViewById()` calls. --- # 11. Settings UI Design Create each setting as a modern Material 3 list item. Each row should contain: * Leading icon * Title * Optional subtitle * Trailing arrow or switch * Proper touch/ripple effect Recommended settings order: ### Account * User Layout ### Preferences * Change Language * Dark Mode ### Information * Terms and Conditions * Disclaimer ### Account Actions * Log Out Use rounded Material cards or appropriately styled preference containers with subtle elevation and spacing. --- # 12. Visual Design Design language: * Modern Material 3 * Minimal * Clean * Professional * Premium * Responsive * White/light background for Light Mode * Proper Dark Mode colors * Rounded corners * Consistent iconography * Proper Material typography * Balanced margins and padding * High accessibility contrast * Touch targets of at least approximately 48dp Avoid: * Old-fashioned UI * Excessive gradients * Excessive shadows * Crowded layouts * Tiny text * Hard-coded colors throughout layouts Centralize colors and dimensions in resources. --- # 13. Firebase Authentication Configure Firebase Authentication correctly. Implement: * Firebase Authentication * Google provider * Authentication state checking * Sign-in * Sign-out * Error handling * Loading states * Session restoration Use the currently recommended Google authentication integration for Android/Firebase rather than deprecated authentication APIs. Explain where the developer needs to add: * `google-services.json` * Firebase project configuration * SHA-1/SHA-256 fingerprints * Google authentication configuration * Firebase Authentication Google provider Never place private API secrets or credentials directly inside source code. --- # 14. Error Handling Handle common cases: * No internet connection * User cancels Google login * Authentication failure * Firebase failure * Account selection failure * Network timeout * Sign-out failure Show user-friendly Material Snackbar/Dialog messages. Do not expose raw exception stack traces to users. Provide useful Logcat messages for debugging. --- # 15. Loading State During Google authentication: * Disable the login button temporarily. * Show a Material progress indicator. * Prevent duplicate login requests. * Restore the button if authentication fails. Example: **Signing in...** After successful login: **Login successful** Then navigate to the dashboard. --- # 16. DataStore Use modern `DataStore Preferences` for local preferences such as: ```text selected_language dark_mode_enabled ``` Do not use SharedPreferences unless there is a specific compatibility reason. Create a clean preference manager/repository. --- # 17. Accessibility Make the application accessible. Include: * Content descriptions for icons * Proper text contrast * Minimum touch targets * Screen-reader-friendly labels * Logical focus order * Accessible dialogs * Scalable text support --- # 18. Navigation and Back Stack Implement proper navigation. Expected flow: ```text LoginActivity ↓ MainActivity ↓ SettingsActivity ↓ UserProfileActivity TermsActivity DisclaimerActivity ``` If the user is already authenticated: ```text App Launch ↓ Firebase Auth Check ↓ MainActivity ``` If the user is not authenticated: ```text App Launch ↓ LoginActivity ``` After logout: ```text Logout ↓ LoginActivity ↓ Clear Back Stack ``` --- # 19. Code Quality Follow modern Kotlin coding practices. Requirements: * Null safety * Coroutines where appropriate * Lifecycle-aware code * Avoid memory leaks * Avoid deprecated APIs * Meaningful variable names * Reusable helper functions * Clean architecture principles where appropriate * No unnecessary libraries * No duplicate code * Proper comments for important authentication logic --- # 20. Deliverables Generate the complete implementation, including: 1. `build.gradle.kts` 2. Project-level Gradle configuration 3. `AndroidManifest.xml` 4. All Kotlin Activity files 5. XML layouts 6. Material 3 theme 7. Light/Dark theme resources 8. Color resources 9. String resources 10. Hindi string resources 11. DataStore implementation 12. Firebase Authentication implementation 13. Google Login implementation 14. Logout implementation 15. Settings implementation 16. Terms and Conditions screen 17. Disclaimer screen 18. User Profile screen 19. Required drawable/vector resources 20. Firebase setup instructions Make sure the generated project **compiles successfully in the latest stable Android Studio**. Do not leave incomplete methods, pseudocode, TODO authentication logic, or missing XML IDs. Before presenting the final code, verify that: * All IDs referenced from Kotlin exist in XML. * All Activities are declared in the manifest. * All required dependencies are included. * Firebase authentication flow is complete. * Google login works using the current recommended approach. * Dark Mode works. * Language selection works. * Logout clears the authentication flow correctly. * The application handles configuration changes safely. * No deprecated Google Sign-In implementation is used. The final result should look like a **modern, polished production Android application**, not a basic tutorial/demo UI.
