Creating apps on niotron is super easy, super simple. You just have to drag n drop the required components. Join some blocks and your app is ready to rock…
The Component‘s behavior is configured using Blocks. Hold on a sec, What is this component? And what is the block? Got confused!
Components are the basic building elements of any app that you are creating on Niotron. Everything in the app is done with the help of one component or the other. Here, different components are used for different purposes. One component may be used to design the User Interface(UI) of the app, for example, a Label component, while others may be used for performing actions like communicating to a server, saving data to the Android device’s folder, etc., for example, the TinyDB component.
There are two different types of components,
- Visible Components, These components can be viewed in the Viewer of the Designer section and are known as Visible Components. They are visible to the user in the app and the user can interact with it directly and help in building the User Interface of the app.
- Non-Visible Components, Those components that are not visible in the Viewer of the Designer section and are known as Non-Visible Components. These components usually do other things like saving a file to the device’s storage, getting data from various sensors of the device, etc. But, sometimes, these components may also be used to create visible elements in the app. For example, the Notifier component, which is a Non-visible Component can be used to create a dialog that is visible on the device’s screen.
Hmm… What are Blocks then?
Blocks are used to describe how to perform a task. How the Components respond to various actions and events in the app is designed using the Blocks.
For example, how the app should respond when a button is clicked, what data is to be communicated to the database using the TinyDB component etc. are all configured using the Blocks.
Thus, by using the various Components and by configuring its behaviour and response to actions from the user with the help of Blocks, an app is "made" in Niotron
Similarly like components, Blocks are of theree different types,
- Property blocks
- Method blocks
- Event blocks
Let's try to understad this in detail.
Each component comes with its own set of Properties, which describe its characteristics. For example, the Button component has properties like Background Color, Text Color, Text Font Size etc. which are characteristics that describe the features of that particular button.
Some these Properties can either be set from Designer page, or through Blocks, while some can be set only through Blocks and some only from the Designer.
At any time in the app, the given property of a component can be read through a Getter Block. It gives the current value of that property of that particular component.
Similarly, the given property of a component can be modified during the runtime of the app thorugh Setter Blocks.
The Property blocks are Green in color.
Not all the properties of the component have both Getter and Setter Blocks. Some of them may have only Getter or sometimes only Setter blocks.
Methods are certain functions that a component can do. For example, the Sound component should be able to play the music when required. This is done by using a Method called Play, which instructs the components to carry out the task of playing the music.
So, Methods are nothing but an instruction to carry out a particular task, like playing the music.
Some methods require some additional data, which will also be used in carrying out that task. For example, Firebase DB component stores the data using a method called Store Value. But how will the component know what data to store and under what name ? This is where Parameters or simply Params are used.
The Store Value methods has takes two parameters(i.e it makes use of two different data that need to be specified) namely tag and value To Store. So this method can be called(i.e used in the blocks) along with the two data that it needs like shown below.
Niotron apps are "made" in an event-driven approach. That is, the blocks or behaviour of the app is executed based on the various events that occur. There is a wide range of events that occur thorughout the time for which the app is running, and the response of the app to these events can be configured.
For example, the user clicking a Button, the app starting are all events. The response of the app to such events are configured by grouping the desired behaviour under the Event block. The methods and property blocks grouped under each event are executed whenever that particular event occurs.
Let us take an example.
If you want to change the Button text when the user clicks it, you have to group the logic to change the text under the Button.Clicked event. This is shown below.