The ClicksVille Kodi addon is a great add-on with a lot of content, but unfortunately, the developer has not updated it for a while. But now, you don’t need to miss out anymore. In this article, I’ll show you how to install the add-on on Kodi 17.6 Leia, and I’ll also teach you how to use it to its fullest potential.
If you’re looking to install ClicksVille Addon on Kodi, you’ve come to the right place. ClicksVille is a Kodi addon that makes it even easier to find related media from your favorite shows. It’s an all-in-one package that not only organizes your media library but also integrates with other Kodi addons like Exodus, Phoenix, and more.
An Android app built with Kotlin that uses the TMDB API to display the most popular, upcoming and trending movies and TV shows. It was built with the pure architecture principle, the repository model, the MVVM architecture in the presentation layer and the Jetpack components.
I created this repository for several reasons:
Explore approaches for implementing pure architecture and SOLID principles in an Android application.
Learn the libraries/tools supported by Google and most Android developer communities.
Experiment with modularization and dynamic function modules.
Study the implementation of the Picture-in-Picture function.
Demonstrate advanced development techniques using a modern technology stack.
To build the application, you need to modify the api key in gradle.properties. First you need to generate your own api key by creating an IMDB account and generating an api key.
Complex architectures like pure architecture can also increase code complexity, as decoupling involves creating multiple data transformations (mappers) and models, which can ultimately increase the learning curve of your code to the point where a simpler architecture like MVVM is preferable.
So let’s get started…
What is pure architecture?
A well-planned architecture is extremely important for scaling an application, and all architectures have a common goal: managing the complexity of your application. This is not a problem for small applications, but it can be very useful when working on applications with longer life cycles and a larger team.
Clean architecture was proposed in 2012 by Robert K. Martin in the Clean Code blog and follows the SOLID principle.
The circles represent the different levels of your application. Please note that :
The middle circle is the most abstract and the outer one the most concrete. This is called the principle of abstraction. According to the abstraction principle, the inner circles should contain the business logic and the outer circles should contain the implementation details.
Another principle of pure architecture is the reversal of dependencies. This rule states that each circuit can only depend on the nearest internal circuit, i.e., low-level modules do not depend on high-level modules, but vice versa.
Why pure architecture?
Free communication between codes – code can be easily changed without affecting all or much of the application’s code base.
It’s easier to test the code.
Separation of tasks – different modules have specific tasks, which makes modification and maintenance easier.
Principles of S.O.L.I.D.
Single Responsibility : Each software component should have only one reason to change – a responsibility.
Open-closed: You must be able to extend the behavior of a component without interrupting its use or changing its extension.
Replaces Liskov: If you have a class of the same type and subclasses of that class, you should be able to subclass the use of the base class without breaking the application.
Interface separation : It is better to have several small interfaces than one large one, to prevent a class from implementing methods it does not need.
Dependency Reversal: Components should depend on abstractions and not on specific implementations. In addition, higher level modules should not be dependent on lower level modules.
This is the basic application layer. The domain layer is independent of the other layers, so domain models and business logic can be independent of the other layers. This means that changes in other layers do not affect the domain layer, for example. For example, a change to the screen interface (presentation layer) or to the database (data layer) does not result in a change to the code in the domain layer.
Include components at the domain level :
Models : Defines the basic data structure to be used in the application.
Deposits : Interfaces used by the use cases. Implemented at the data level.
Examples of applications/interactions: They encapsulate a single action, such as retrieving data from a database or sending a message to a service. They use benchmarks to decide what action to take. They usually replace the invoke statement, so they can be called as a function.
The data layer is responsible for selecting the correct data source for the domain layer. It contains the implementations of the memories declared in the domain layer.
Data layer components include:
-Therefor models: Defines the POJO for network responses.
-Asset models : Defines the SQLite database schema.
Deposits : Responsible for data transfer at the domain level.
Cartographers : You convert data between domain, dto and entity models.
Network: He is responsible for the implementation of network operations such as. B. the definition of the API endpoints with the retrofit.
Cache : It is responsible for performing caching operations with Room.
Data source: Responsible for choosing the data source (network or cache) to use when retrieving data.
The presentation layer contains components that participate in the presentation of information to the user. The main components of this layer are views and ViewModels.
This project uses many popular libraries, plugins and tools from the Android ecosystem.
Observer Model – An observer model is a software design pattern that defines a one-to-many dependency between objects such that when one object changes state, all dependent objects are notified and automatically updated.
Example of a warehouse : The repository model is a software design pattern that prevents us from working directly with the application’s data and creates new layers for database operations, business logic, and the application’s user interface.
UseCase Pattern – The UseCase Pattern is a software design pattern used to bridge the gap between business and system models without changing the content of the requirements or anticipating architectural options.
Hilt – Dependency injection library.
Android KTX – Provides concise and idiomatic Kotlin for Jetpack and the Android platform API.
AndroidX is a significant improvement over the original Android support library, which is no longer supported.
Life Cycle – Perform actions in response to a change in the life cycle status of another component, for example. B. Actions and fragments.
LiveData is lifecycle aware, meaning that it respects the lifecycle of other application components, such as actions, extracts or services.
ViewModel – Designed to store and manage lifecycle data related to the user interface. The ViewModel class allows data to survive configuration changes, for example. B. Rotate the screen.
Data binding – allows you to bind UI components in layouts to data sources in your application using a declarative format, rather than programmatically.
Room – Provides an abstraction layer over SQLite used for offline data caching.
The Navigation component is a component that allows you to simplify the implementation of navigation, from simple button clicks to more complex models.
MotionLayout – Helps you create and manage beautiful user interface animations.
Retrofit is a type-safe
http client and supports coroutines out of the box.
GSON is a JSON parser used to parse
level queries for entities and contains
non-zero parameters – and defaults to Kotlin.
OkHttp logging interceptor – logs data from HTTP requests and responses.
Coroutines – The library supports coroutines.
Streams – Streams are built on coroutines and can provide multiple values. Conceptually, a stream is a data stream that can be computed asynchronously.
Timeline to facilitate logging.
Material Design – for stunningly beautiful user interfaces.
Glide images library- to load images from the database and store them in memory.
kotlinx.coroutines- library to support coroutines, provides the coroutines runBlocking constructor used in testing.
Truth – Assertion library, provides readability over assertions.
MockWebServer is a web server for testing HTTP clients that validates requests and responses from the TMDB API with a retrofit client.
GitHub Actions – GitHub actions are used in this project to check syntax correctness with KtLint, run unit tests, and create a new package if errors are made on the main branch.
KtLint – The project uses KtLint to check the correctness of the syntax.
In this section I have listed some of the sources, i.e. articles and GitHub repositories, that I used to create the :
Robert K. Martin’s Pure Code blog.
Detailed guide to android app development with pure architecture model medium article.
Clean architecture component Boilerplater Repo GitHub.
Force GitHub repo by David Odari demonstrating the use of
Clean architecture tutorial for android article by Raywenderlich that is really beginner friendly.
Article on pure architecture in android on Medium.
Introduction to application architecture and Introduction to application modularization – Article from ProAndroidDev.
Other useful resources.
In this section, I’ve included resources that are not purely architecture related, but have been very helpful for learning other Android components and tools:
Pokedex GitHub repo by Ronnie Otieno demonstrating how to use various Jetpack components.
The basis of the test on the official android developers website.
Android MotionLayout Tutorial – Retractable View – A blog post on how to create a retractable view with MotionLayout.
MotionLayout Blog – Collapsible Toolbar shows how to create a collapsible toolbar with MotionLayout
Introduction to Github actions for Android Mindorks blog on customizing GitHub actions for Android projects.
Here you can find screenshots of the application:
Frequently Asked Questions
How do I install ClickSville?
ClickSville is a free and open-source software. You can download it from the official website.
How do I install dependencies on Kodi?
You can install dependencies on Kodi by using the following commands: sudo apt-get update sudo apt-get install libc6 libncurses5 libstdc++6 g++ make How do I install dependencies on Ubuntu? You can install dependencies on Ubuntu by using the following commands: sudo apt-get update sudo apt-get install build-essential libncurses5 libstdc++6 g++ make How do I install dependencies on OS X? You can install dependencies on OS X by using the following commands: sudo port install libc6 libncurses5 libstdc++6 g++ make
What is ClickSville?
ClickSville is a website that allows users to create their own clickable maps. What is a clickable map? A clickable map is a map that allows users to click on different locations and see information about those locations.