Building custom Android apps with a universal app constructor
Tags: android, lowcode
Published: 2023-01-27 10:06:17

Hey there fellow developers! 

I'm Vitaliy and I've been **developing for Android** for a while now. In this article, I want to share my journey of discovering and working with a low code platform. From my first encounter to my current understanding of its capabilities. 

I'll take you through my personal experience and the exciting things I've been able to create with it.



## A bit about myself




I've been working as an Android developer for **about 8 years** now and have had the opportunity to work on a wide variety of projects. From building apps that use **GPS, Wi-Fi, and Bluetooth** for location tracking, to creating apps for smart homes and working with BLE sensors, I've had a lot of experience in different areas of Android development. Some of the technologies and libraries I've used throughout my career include Retrofit2, Dagger2, Firebase SDKs, Play Services, Android Architecture Components, Gson, Okhttp3, Picasso, Room, Stetho, Butterknife, play-services-location, Moxy, Mosby, MPAndroidChart, and Glide.



![me](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/orv7ycefbckqosg5g700.jpg)

Two years ago, I was starting to think about finding a new project and a friend of mine introduced me to the world of low-code platforms. I was intrigued and decided to give it a try. That's when I discovered MarsX, a low-code platform that allows developers to create mobile and web applications quickly and easily. I was immediately drawn to its simplicity and flexibility. I decided to dive in and see what it was all about.


## Android app-constructor



As I mentioned earlier, it all started with a friend's advice and fatigue from an old project. The company needed an Android developer, we spoke, and discussed the project, its features, and development prospects, and it made me curious.

I started developing **Android client applications** for interacting and displaying what developers create on MarsX itself.

It is a bit confusing, so here is a bit of an explanation. I make **applications that can display the content of websites that other developers create** using MarsX. So I'm working on an app (essentially a constructor) that uses native elements to display what MarsX sends. For example, if a customer needs a mobile app with their own logo, name, structure, content, etc. to release on the Play Market, I create that app (constructor) that can display any MarsX blocks as native, and then the guys add and modernize the structure and content of the app.

Android and iOS apps are like a separate ecosystem that allows you to create client apps (with icons, names, etc.) in just a few hours and then sent to the Play Market.

**The app is like Lego** that is assembled into what the customer needs. It's a very interesting and dynamic process because you can do almost anything with it.

MarsX can show anything that comes to the developer's mind. In essence, we are already creating an app so that the developer who supports, for example, a specific cinema does not think about the website, Android app, and iOS app (that's already at least a 3-people team), but only MarsX itself to control everything at once. One ring to rule them all, as in the Lord of the Rings.


![One ring to rule them all](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8i4ej64lkdix513zz5io.gif)


## Is MarsX any better than other languages for app development?



MarsX offers a **universal app constructor** that can build almost any screen you can imagine, from a social media app like Instagram to a flower shop app or even a cat shop app. The constructor utilizes MarsX commands to indicate which blocks to use, what content to include, and how to arrange everything to achieve the desired look and feel.

One of the things that I love about using MarsX is that it allows for a high degree of **flexibility**. For example, instead of being limited to displaying movies (like on my current project), you can show pictures, stories, user profiles, and so much more. Essentially, anything can be implemented using MarsX' tools and blocks.

> My team even created a demo that looks almost identical to Instagram, which is a testament to the power and versatility of MarsX.

In my experience, when creating an app, I base my decision on the app's functionality. In most cases, apps are simply data displayed from a server without specific tasks. In such cases, I would choose MarsX. It is quick, efficient, and allows for easy changes to be made. The constructor allows you to quickly change blocks and see the result, saving a lot of time and effort.


## **Pros and cons of Low Code**



As with any technology, especially a new and which is in beta, there are many pros and cons here. I will describe some of the ones I have encountered.

**Pros**:

- Simplicity and speed of developing new apps. From an Android project, **you can create an app constructor in about an hour** that will be ready for deployment to the market. Then, the structure, colors, and content of the app are configured. Users can already download and use the app, and further development continues on MarsX.
- Simplicity and speed of making changes (content, structure, colors). If edits are needed for a published app, they can be made on the MarsX side, and after applying the changes, **the app immediately receives them without waiting** for the store's review and the user to update.
- Fast reaction to failures, incorrect data, and non-working blocks. In standard apps, if there is a non-working element, a block that doesn't work properly, or other issues, the user has to wait for the store to review and approve the update to fix it. On MarsX, this process is significantly faster since **updates are applied immediately**.
- The simplicity of developing new blocks. Given that the app is essentially a constructor, to add a new UI element (if it cannot be customized) or functionality, the developer needs to create a new block, implement basic behavior, and add new features. Specifically, in this case, the app needs to be updated, but due to the dynamic structure, **the missing block in the outdated version can be worked aroun**d in any available way.

**Cons**:

- The speed of work. At the moment, necessary corrections and optimizations have been made, but due to the fact that blocks are created dynamically, **the speed of work of a standard app with pre-defined screens will be higher** due to the absence of the need to create them and receive a greater amount of data.
- The absence of specific features and blocks. This disadvantage can be attributed to all app development tools. Developers who need a narrowly focused function (for example, video editing, music, natively implemented real-time charts, etc.) **have to add their own blocks** with the necessary implementation, but as MarsX develops, such blocks become fewer, and the process of adding becomes easier.

I am actually impressed with how low code has grown in the last two years. It is now difficult to imagine similar ease of development using other technologies.