zakirpervez / PopularMovies

The PopularMovies app helps you find classic favorite movies and lets you see more information about them.

PopularMovies

The PopularMovies app helps you find classic favourite movies and lets you see more information about them.

Getting Started

Discover the latest and greatest in the world of cinema with our Popular Movies app. Whether you're a film enthusiast or simply looking for your next movie night selection, this app is your one-stop destination for all things movies.

Software Stack:

1. Android SDK
2. Kotlin
3. Compose
4. Jetpack Navigation Component
5. Jetpack Paging
6. Android Architecture Components
7. Koil
8. Retrofit
9. Hilt Dagger
10. Coroutines
11. MVVM
12. Junit4
13. MockK

Git branching strategy

A Git branching strategy is a set of rules and guidelines for managing and organizing branches in a Git repository. It helps teams collaborate, maintain code quality, and streamline the development process. There are several branching strategies like Truncate based development, Git Flow etc.

For this project, I plan to use a truncate-based development strategy. Given that I am the sole contributor in this project, using this approach aligns well with the project's needs.

1. `main` - Main branch, always stable and ready to deploy.
2. All the feature branches should be created from master branch.
3. All the feature branches should be merged into master branch.

Note: As I am single developer, I am not creating any feature branches. I am directly pushing the code to master branch.

Commit guidelines

Commit should always be make in following format

type(scope): [commit-details-message]-[ticket/issue_number]

type: Type should be represent the nature of commit. It can be one of the following.

1. feat: A new code which is return for the feature.
2. fix: A bug fix.
3. refactor: A modification inside the existing code.
4. docs: Documentation only changes.
5. release: Release of new version.
6. test: Adding or updating tests.
7. chore: Updating build tasks, package manager configs, etc; no production code change.

scope: Scope indicates the module, component, or part of the project the commit affects. It can be one of the following.

1. Component
2. BugFix
3. Module
4. App
5. Api

commit-details-message: A short, concise summary of the changes.

ticket/issue_number: Represent JIRA/Github/Gitlab ticket/issue number.

• Note:

1. There is no git pre-hooks added.
2. As I don't have any JIRA/Github/Gitlab ticket/issue number, I am assuming a ticket no TN:10000 and adding it in my commits.
3. No CI/CD integration [Gitlab/Github/Bitrise/Bamboo/Fastlane etc would be good candidates]

*

Architecture Used

This is application is built using a MVVM architecture.

Testing

1. Unit Testing: Unit test cases are added.
2. Instrumentation Testing: No instrumentation test cases are added.

Security

1. Network security config added
2. Proguard/Dexguard is not added

*Note: Not adding the proguard/dexguard.*

Interceptor/CodeAnalysis/Logging/Memory Detection Tools

Integrated following tools inside the app

1. lint:

   Lint is a static code analysis tool provided by Android Studio. It helps identify issues in Android project code that may cause runtime errors, security vulnerabilities, performance problems, or other code quality problems. Lint performs a wide range of checks, including identifying unused resources, detecting layout performance issues, highlighting potential security vulnerabilities, and more. It provides suggestions and warnings to help developers write better code and follow best practices.

2. kt-lint:

   KtLint is a Kotlin-specific code style checker and formatter. It enforces a consistent coding style in Kotlin projects by defining coding rules and then applying those rules to the source code. KtLint helps maintain a uniform and readable codebase by automatically formatting code and highlighting deviations from the defined style rules. It is often used in conjunction with Kotlin projects to ensure code consistency and adherence to a project's coding standards.

3. detekt:

   Detekt is a static code analysis tool for Kotlin that helps developers identify issues and enforce coding standards in Kotlin codebases. Similar to Lint for Android, Detekt analyzes Kotlin code for various issues, such as complexity, code smells, potential bugs, and anti-patterns. It provides a set of configurable rules to detect issues and can be customized to match the coding standards and guidelines of a project.

4. leak canary:

   LeakCanary is a memory leak detection library for Android applications. It helps developers identify and diagnose memory leaks in their apps. Memory leaks can lead to increased memory consumption and application crashes, so LeakCanary is a valuable tool for finding and fixing such issues. It automatically detects and reports memory leaks, providing detailed information about the leaking objects and their references, making it easier to address the problem.

   
5. Timber:

   Timber is a popular logging library for Android applications. It provides a simple and efficient way to log messages and debug information in your Android app. Timber offers several benefits over the standard Android logging methods

Note : No other network interceptor and crashing tools are added [Chuck/Stetho/Crashlytics/Sentry]

App Screens

1. Splash Screen: Stay for 3 seconds and then navigate to Home Screen.
   
2. Home Screen: Show list of movies. User can click any movie to check its details.
   
3. Movie Details Screen: Show movie details like title, release date, rating, overview etc.
   
4. No data screen: Display a message or take action when the API doesn't return any data or when an error occurs.
   
5. No internet connectivity screen: Display a message when there is no internet connectivity changes