batuhangunes / noteapp Goto Github PK

• About the Project
  • Architecture
  • Components
  • Features
  • App Screenshots
  • App icons
  • Libraries Used
• Getting Started
  • Built With
  • Prerequisites
• Versioning
  • Auto-versioning
• Contact

This is simple notes app. User creates notes. These notes are kept in the internal memory and listed to the user. The user can delete or edit the listed notes.

Android clean architecture was used for this project. It can be installed with clean architecture MVVM or MVP. In this project, this structure was used together with MVVM. clean architecture works in the simplest way in (Figure 1).

As seen in (Figure 1), it consists of 3 main layers. Of these main layers, Presentation and Data layers are dependency on the Domain layer. At the same time, all of these 3 main layers are one module. For a modular project, each module in the project contains these 3 main layers within itself. In this project, only one module was created. Modules can be added with new features. This architecture is conducive to extensibility. You can examine the above-mentioned clean architecture in more detail in (Figure 2) and (Figure 3).

1. Navigation Components - Navigation component helps you implement navigation, from simple button clicks to more complex patterns, such as app bars and the navigation drawer. The Navigation component also ensures a consistent and predictable user experience by adhering to an established set of principles.

2. Android Room Persistence - The Room persistence library provides an abstraction layer over SQLite to allow fluent database access while harnessing the full power of SQLite. Room provides compile time checks of SQLite statements and can return RxJava, Flowable and LiveData observables.

3. Kotlin Coroutines - A coroutine is a concurrency design pattern that you can use on Android to simplify code that executes asynchronously. On Android, coroutines help to manage long-running tasks that might otherwise block the main thread and cause your app to become unresponsive.

4. ViewModel - It manages UI-related data in a lifecycle-conscious way. It stores UI-related data that isn't destroyed on app rotations.

5. LiveData - It notifies views of any database changes. Use LiveData to build data objects that notify views when the underlying database changes.

6. Kotlin - Kotlin is a modern statically typed programming language used by over 60% of professional Android developers that helps boost productivity, developer satisfaction, and code safety.

      It also uses RecyclerView with DiffUtill to improves overall app performances
   

1. Save Note In a Local db
2. Update
3. Delete
4. Swipe To Delete
5. Undo Delete Operation
6. Upload Image From Url and Stores in local db with a note
7. RecyclerView Animations
8. Edittext Animations
9. Fragment Transition Animations
10. Splash screen
11. Landscape and portrait orientation support
12. 2 different language support in Turkish / English

	Means / action
	Redirects to the relevant fragment to add a new note
	Indicates that the corresponding note was not updated after it was created
	Returns from fragment
	indicates that the field contains date information
	Saves the changes made for the active note
	Deletes the active note
	Indicates that the swipe to delete operation has started
	indicates that the corresponding note was updated at least once after it was created
	Indicates that the editable feature of the active note is disabled
	Indicates that the editable feature of the active note is active
	Initiates image download flow via URL
	Removes the image attached to the note. It also replaces when the image cannot be loaded for some reason.
	Starts the flow of taking pictures from the camera (this feature is not supported in the latest version)
	Starts the image selection flow from the gallery (this feature is not supported in the latest version)

• Room
• Dagger - Hilt
• Glide
• Splashscreen
• Coroutines
• Material library
• Navigation Component
• Yruth
• Espresso
• Junit
• Core-testing

The project is available by copying it from the git repository.

• Java 11
• Kotlin Plugin

• A physical or virtual device capable of running an android application so that the application can be tested or run (minSdkVersion = 23).

This project follows semantic versioning standards. There is 3 main identifiers of a version of the software. MAJOR, MINOR and PATCH. These 3 identifiers are numeric and separated with dot in the version. This means these numeric values should be increased in the following way;

• MAJOR version when backwards incompatible API change
• MINOR version when adding feature to the API with backwards compatibility
• PATCH version when refactor or bug-fix with backwards compatibility

Version code is an integer value. In this project version code is calculated using major, minor and patch numbers. These numbers are defined as a variable in the app/build.gradle file.Version code is calculated by multiplying major by 100_00 and adding minor that multiplied by 1_000 then adding the patch version integer. This way patch number can have a value between [0-999], minor can have a value between [0-99]. Version code can have a value up to 2_100_000_000.

This project contains hook scripts to automate the version upgrading process. When you commit some changes it will prompt a screen to ask you the scope of the project. Please input major, minor, patch or ignore depending on your development. Then the scripts will automatically increase the respected version in the build.gradle file. Git uses .git/hooks/ directory for triggering hook scripts. But this directory is not version controlled. So we need to create .githooks directory and tell git to check this directory for hook scripts. To do that please run the following command;

git config --local core.hooksPath .githooks/

• Github Profile
•