Brian McHarg's strategy to successfully develop cross-browser, cross-platform HTML5 games.
HTML5: the rightful heir to the throne of flash games. Truly cross-platform development allows you to run a program once written on a PC, tablet and smartphone, it will also work on Smart TV, and on desktop and mobile devices, including game consoles like Xbox360 or PlayStation 3 through their built-in browsers. It is clear that this is very attractive for those who want to develop games for as many devices and platforms as possible.
The term HTML5 itself, as well as the specifications it represents, has different meanings depending on who is describing it. For clients, this is a development technology that promises a true holy grail - and cost-effective cross-platform development.
For developers, it's a collective noun for many different technologies: JavaScript, WebSockets, WebAudio, Canvas, CSS3, and WebGL to name but a few, each with its own standards, strong weak restrictions from platform to platform.
And finally, it seems, the most important thing: for users! The only thing that matters here is that users want to get the same impressions and experiences that they are used to. And this is the main task for developers, especially if their goal is to introduce the game to as many platforms as possible.
PC vs mobile cross-platform
By now, we all know fantastic examples of HTML5 games that run on PC browsers. They are often created by browser authors to demonstrate a particular strengths own software, or for specific APIs they would like to see ratified in the HTML5 specification.
Games like Cutthe Rope and Contre Jour for Internet Explorer or some of the excellent experiments for Chrome browser like Jam or Racer are great examples. If you're interested in the potential for the future, check out libraries like three.js, the recently released open source Turbulenz, or Epic HTML5 powered by Unreal Engine.
However, try looking at one of these examples on an Android with OS2.3 (Gingerbread) installed and you'll see a completely different picture, and in some cases nothing at all. Yes, this operating system is almost three years old, but it is still installed on a third of all Android devices, and this figure can be even higher depending on your target audience. And this happens not only in old version Android. You can see the same on Apple devices running iOS 5 or less powerful devices such as Kindle Fire. In fact, right now you will not find any mobile device that will correctly display any of the above programs.
As mentioned earlier, most customers choose HTML 5 for their browser game to be truly cross-platform. If you're developing PC-only games, then Unity and Flash are great options to look into. Both have - great support browsers and the ability to export to devices as individual applications, thanks to which they can be transferred to a smartphone or tablet with the very code that you need.
There are two obvious problems when developing a cross-platform game in HTML5. The first is a consequence of the fuzzy nature of the HTML5 specification, whereby future support is split not by device type, but by browser type on each of those devices. The second, and most difficult for developers, is the constant change in the capabilities of mobile devices, which means that even with the same set of functions, the game on one device will be very different from the same game installed on another gadget.
To get an idea of how many options there are, just run one of the many JavaScript tests to test device performance. For example, passing 100 frames through Canvas will play relatively well at 60 frames per second on devices like the iPhone 4S or 5, Galaxy S3, Nexus 7, or Lumia 820. But try the same code on other devices like HTC Desire(19fps) Galaxy Ace(7 fps) or iPad 1 (9 fps) and you'll have to work really hard to get anything like a viable game.
If your project was targeting a smartphone or tablet, and especially if these included older or low-powered devices, then it is very important to test and define benchmarks at an early stage. This is necessary in order to understand the limitations of the range of devices and decide on both the technical approach and the design of the game you will be working on.
If your project wasn't aimed at smartphones or tablets, then you probably need to rethink your goals. For example, almost a third of UK page views are on smartphones and tablets, and this figure is growing at a rate that will overtake PC page views as early as 2014. While desktop devices still dominate work hours, mornings are leading the way. mobile devices, and in the evenings - tablets, and these two time periods are ideal for browsing the web and playing games.
Choose your battles
Chunk has been developing HTML5 cross-platform games for broadcasters and brands for two years now, and has created browser-based mobile games for clients like the BBC and Disney that run on everything from HTC Desire to iPad4, Nexus 7 to Xbox. 360. 
As developers, it would be great for them to decide how deep to embed in this process, but this is determined by their target audience and the devices they use. While working on children's brands, they often had to find themselves within the limitations of old phones, or low-cost and low-power devices, but at the same time carefully design and optimize many other things, which is why they still believe that it is possible to develop impressive games for mobile. the Internet.
And what did they take away from this experience? Well, if you had to make a list of 10 best advice for HTML5 game developers, it would look like this:
1. Decide on an audience
Look at the demographics and what devices are being used by the people you're targeting. If you have the data, use it to identify the top range of devices your visitors use and base your decisions on those devices.
2. Decide on the design in terms of technology
Yes, this should always be the case, but the limitations and fragmentation in HTML5 make it even more relevant. WebGL will allow you to make an excellent 3D first-person shooter, but it's unlikely (read: not at all) to work on tablets if they're on your target platform list.
3. Befriend caniuse.com
It's a great way to quickly test support for any HTML5 feature you'd like to use in your development—for virtually all browsers and devices.
4. Use Devices, Not Just Simulators
Get your hands on as much as possible various devices, run as many different versions of operating systems as possible. Simulators will help you during development, but you can only get an accurate picture of how your code will work on a real device. There are a huge number of labs with test devices like the Open Device Lab that will give you access to a huge number of devices. Otherwise, look for resources like eBay to find old phones and add them to your test environment.
5. Be aware of changes
The HTML5 specification is constantly changing, as is device support, so you need to keep up to date with changes in these areas. This is especially true in areas such as audio, where features like the WebAudio API can radically change the experience.
6. Be flexible throughout development
What works today may not work tomorrow. What is not available to you today can become available tomorrow. Allow yourself to be flexible and adapt to the changes that occur during your work.
7. Scale functionality
Putting mobile first is useful for more than just traditional web design. Look at how you can create something good for smartphones, and then decide on the functionality and performance on other platforms, if they allow it. Work for those devices that use user agents or media devices and apply your experience with them.
8. KISS (Keep It Simple, Stupid)
By all means try to define the boundaries and expand the possibilities, but remember that you are working with technology that is in its infancy, increased complexity or overestimated project ambitions will only worsen your situation.
9. Decide on the lifespan of your designs
Capabilities change all the time, and your content can become outdated too quickly with new features available on devices. If your game should last long enough, take the time to fix bugs and update the game version.
Oh yes. Check your games for everyone available devices as often as possible!
Gladiator, you ride on my second signal
HTML5 seems to be the unofficial core technology for cross-browser cross-platform game development, there's not the slightest doubt about that. IN this moment is not the most reliable space, but it is normal for technology in its infancy. To check the capabilities of browsers, you should familiarize yourself with sites like caniuse.com. Regularly check your games for as much as possible more devices available to you, and be pragmatic with game design. This will help you avoid problems not only now, but also be in a better position when device support improves, which is inevitable.
Free games on Android. Made in html5, so they can be played on your phone and tablet. In addition to the Android system, Windows, Linux, Mac and Apple mobile devices are supported. The main thing is that the browser is modern and the system is new. Mouse or touchscreen control.
Android games are perfect. They can be played on PC and phone. They can be downloaded (installed) for quick access.
How to download HTML5 game on your phone
Go to the game page on our website. Open the game in full screen in a modern browser like Chrome. Click in the browser on the button with three dots, which hides the menu commands for working with the page. Scroll down the list and select "Add game to main screen” (Add to Main Screen - if you do not have Russified Chrome). After that, the game will appear on the screen of your phone and it will be possible to launch it directly, without launching a browser.
This operation is available for phones and android tablets and Apple, but for the latter, the command may be located elsewhere - in the bottom menu of Safari.
The game may require Internet to work (or may not, depending on the specifics of the particular game - a number of games are available for offline, but this should be checked now.) The game is automatically downloaded and saved on your phone, but a connection may be needed to download online leaderboards or other features.
Install as a normal Android game
Almost every HTML5 game has a version under operating system Android or iOS. If installing an HTML5 game on your home screen doesn't suit you - let's say you want to play all the time, and not just when there is Internet - then look for the icon in the intros of games Google Play and AppStore. Although games are released less often for apple devices, and more often you can see only android buttons, like this:
Install button - look for it in games
In the games themselves, the button is significantly smaller, here it is enlarged so that you remember it. Pay attention to the screenshot of the game below - try to find this button there. They lead to the official Google Play, where you can download free version games with advanced features - like the ability to play offline.
Dedicated to fans of the game on Android ...
When they first told me that such a thing exists, I didn’t pay much attention, since I’m generally not a big fan of all these newfangled trends. However, then I realized that Android games are something like "platform" toys - I immediately wanted to try what it is. I still remember how exciting the games for the "eight-bit" prefix Dendy or Sega seemed to me. And here civilization has come to what - just think, a phone without buttons and with a function that allows you to play games. It's tempting, don't say anything!
In fact, a game is installed on your phone (or the game process is carried out exclusively through the browser - this option is also being considered), paying attention to which you can compete not only with artificial intelligence (meaning Personal Computer), but also with other participants (the whole process takes place online).
Obvious Benefits of HTML5
It's no secret that HTML5 is replacing Flash and is the foundation of the modern Web. It is for this reason that games created on its basis began to function within the Internet - moreover, today games that make it possible to compete with other users are increasingly providing interest to customers (especially if it is not necessary download and install on your computer). This feature, in turn, helps to get rid of many malware, which do not allow you to work on your PC.
All these Android and PC games are created under modern browsers and they only require JavaScript, Canvas and HTML5 to function successfully. Depending on what tasks will need to be performed during this game, it is customary to distinguish some varieties:
- Arcade
- brain teaser
- Strategies
- Flying
- Adventures
- Race
- Downloadable
- Browser
Examples of online games for Android
Previously, I was not interested in playing games on the phone at all, but everything changed after I got to the site site. There I got acquainted with what online games on Android are, I tried a huge number of different “toys”. As for me, best games for Android, presented on this site (and not only on this one) - mahjong and.
Why do I say so? Everything is very simple. All my life I prefer games with a strategic bias, and with a clear tinge of medieval themes, as well as fantasy. So I can say that I really found what I like. But that's not even the point.
What I liked most about this site is that it contains the most different types online games, and besides - indeed, they all require very little in terms of software (really, apart from JavaScript, Canvas and HTML5, nothing is required for their work).
Free games for Android
Thanks to the Free2Play model, all Android games presented on this site are free. They can be played in full screen on both PC and tablet. But the main thing that distinguishes them from flash games is that they can finally be played on the phone.
The underlying technology that makes HTML5 games possible is a combination of HTML and JavaScript. Hypertext Markup Language (HTML) was part of the early Internet superhighway as they called it back then and has continued to be used to serve every website today. JavaScript code was added to second version browsers like Netscape 2.0 in 1995 and has evolved over the years to become more pleasant to read and write. In the early days, it was referred to as DHTML or dynamic HTML because it was allowed for interactive content without a page refresh. However, it was difficult to learn and use in the early web era. Over time Javascript with the help of the Google Chrome developers became one of the fastest scripting languages. It also has more freely available modules, libraries, and scripts than any other coding language.
The early DHTML games were very simple. Some examples of the games back then were Tic-Tac-Toe and . As games made with this technology use the open standard of HTML5, these relatively ancient games are still playable today in a modern web browser. These technologies have moved to the forefront of browser games because they don't require plugins and are safer to play than older technologies. HTML5 games also support and the capability has improved to support complex 2D and
Instead of an intro.
After spending several days in a row (without a break for sleep) studying HTML5 support for all my favorite Android gadgets, I decided that this topic is worth paying attention to. In the article I will try to reveal step by step all the stages (of course, basic / key / main) of creating HTML5 gaming application for Android from idea to release APK file.
Perhaps I will not reveal anything new to venerable developers, but for beginners I will try to describe everything as simply as possible, with screenshots and explanations.
Those who wish to learn more, I invite under cat.
Idea
In general, a lot can be said about the potential of Android, about the development of HTML5 and about their interaction. I won't do it. So, straight to the point.
The idea of creating a game for Android probably sits in the minds of tens of hundreds of developers, and those who consider themselves as such. I'm not an exception.
Why HTML5? - Nativity. You write a game in JS, and then for absolutely any OS you create a wrapper in a convenient form and in any Language.
The whole process will be divided into several steps and the final application will consist of two parts:
- Wrap (in this case for Android)
- A game
Step 1. Writing the game itself
Another benefit of writing a game in HTML5 is the fact that it doesn't require a bunch of running programs, IDE, emulators and so on. All you need is a browser (Chromium in my case) and text editor(bluefish)
The game will be simple: if there is a blue rectangle and there is a green rectangle. The player's task is to drag the blue rectangle onto the green one, bypassing the red one, which moves across the playing field in an arbitrary direction.
For game development I will use J2ds (game engine)
Finished game code:
index.html
You can ignore the quality of the game code, because this is not the purpose of the article. Although, of course, you can optimize as much as you like, this process is generally probably endless.
Step 2 android studio. Creating a wrapper for the game
I'm not going to measure the coolness of this or that IDE for Android development with anyone, but I'll show you on Android example studio. For work we need:
- Java machine (OpenJDK is suitable for my Linux)
- Android Studio distribution.
Download, install.
Once everything is installed (These two programs are enough), launch Android Studio. 
The start window will open (if it’s the first launch), if not the first one, then the IDE itself will open, but it doesn’t change the essence, let’s go to the SDK Manager: 
Here you need to check the boxes you need android versions, with which you will work, in my case it is Android 4.4.2, you can choose at least all at once.
The main thing - be sure to select "Tools" and "Extras" and click "install packages".
As soon as everything has downloaded, the IDE will start with a dull gray background and several buttons, press the first one and create a new project. If the IDE started immediately in working condition, then: "File-> New-> New Project" 
Fill in the required fields and click Next
Select the desired version of android and Next
Here we select Blank Activity (an empty template with Hello, World!)
In the next window, fill in the data for creating classes, I will not change for clarity: 
We solemnly press Finich and wait until the IDE configures and prepares everything for work. 
The form designer window will open. It is not the same as in Lazarus, Delphi, but there is still something similar: 
Do not rush to change anything or click something, the setup is not over yet.
Open "Tolls->Android->AVD Manager" to configure the emulator. 
Here, if there is nothing, click "Cereate Virtual Device", if there is, you can not create a new one, I already had it, because I "stumbled" it while I figured it out. If you need to create a new emulator, then everything is simple there:
1. Choose the screen size and phone model
2. Choose the version of android (I have 4.4.2)
3. Set up the device.
In the third step in more detail: 
T.K. the game is stretched horizontally, you need to select the landscape mode.
When all the settings are entered, click on the green triangle and start the emulator. After starting, we wait until the device is fully loaded and the OS starts: 
Do not close this window, emulation will take place in it. Now you can return to the editor and change the orientation in the form designer: 
You can run! Now it's definitely possible.
If you are prompted to select an emulator, you can check the box below: 
Congratulations! Everything works, checked! 
Minimize our emulator (But don't close it!) and go to the editor. Everything is a bit more complicated (a little bit) there.
You need to switch to the "Text" mode. In your activity_main, all the elements that are on the form are described. Including the form itself. And it's not a form at all =).
Because we're making a game in HTML5, and here we just have a wrapper for the game, we remove all the text and paste the following:
Now, if you switch back to the design, it will look different: 
As you can see, now instead of “Hello, World”, a WebView stretched to full screen flaunts in full. This object is our "window" to the game world.
You can even run, see if it will White screen. Move on.
And then we need to go to our project, for this we open the “Project” field on the left and select the “Android” tab, if it is not selected: 
This tab shows the structure of the project and all of its internal files and resources.
spoiler title
We need to find the "manifest" file and add "application" to the definition next line:
android:hardwareaccelerated="true"
It's time to work on the functionality of our "browser", because this is it! Open the "MainActivity.java" class and remove everything unnecessary, leaving only the main one:
spoiler title
Package com.soft.scanner.demogamehtml5; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; public class MainActivity extends AppCompatActivity ( @Override protected void onCreate(Bundle savedInstanceState) ( super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ) )
If you haven’t forgotten, we added a WebView in the activity_main file, pay attention to the bold line:
android:layout_height="fill_parent"
android:id="@+id/webView"
android:clickable="true"
android:scrollbars="none" />
We need to declare an object of the WebView class.
To do this, add to the list of imports:
Import android.webkit.WebView;
And then we declare our myWeb object inside the MainActivity class:
Protected WebView myWeb;
Now, after the line setContentView(R.layout.activity_main); paste the following code:
/* Find our browser */ myWeb= (WebView) findViewById(R.id.webView); /* Set up our browser */ myWeb.getSettings().setUseWideViewPort(true); myWeb.setInitialScale(1); myWeb.getSettings().setJavaScriptEnabled(true); /* Load the page */ myWeb.loadUrl("file:///android_asset/index.html");
Here's what I got in the editor: 
And here's what's in the emulator: 
If you feel the same way, we are on the right track!
There is little left to do:
Where we load the page in our browser, the path to the file looks like this: "file:///android_asset/index.html"
It should be noted that we can store any files inside our game, having access to them.
In our case, the key folder is "android_asset", let's create it (yes, it's not in the project by default):
“File -> New -> Folder -> Assets folder”, a window will open where you just need to agree with the IDE.
Noticed? The project has a new folder: 
Right-click on it -> "Show in Files", the system explorer will open (in my case, Nautilus), pay attention to the path to the folder. Keep in mind that the folder is called "assets" but is accessed via "android_asset". 
Then everything is quite simple - copy our game to the assets folder: 
The index.html file is the same index from the beginning of this article. Well, let's try to run! 
A little advice: it is best to test on a real device via USB, so the test results will be clearer, and mouse control is not the most convenient option, not to mention multiple clicks.
Step 3Android Studio Building the application and signing it
When the game is fully debugged by you (in a browser or on an emulator), the wrapper is completely ready and all development stages are over, you can build the application. Android Studio lets you build apps and sign them with your keys.
To create keys in this IDE there is special utility key tool.
Let's move on to creating an executable application file ("Build -> Generate Signed APK"): 
If you have not created keys and aliases before, click "Create New"
You can fill in the fields at your discretion, the accuracy of the data lies entirely with you. 
The first field is the path to the folder where the key will be saved.
After clicking Ok, the form will be filled in automatically: 
For subsequent applications, it is not necessary to create new keys, you can sign other applications with your key, this is exactly what the “Choose Existing” button is for
In the next step, the IDE will ask you to enter the password again, and then specify the folder to save the APK file.
admin in the category Uncategorized. Add to bookmarks.
Those who wish to learn more, I invite under cat.
Idea
In general, a lot can be said about the potential of Android, about the development of HTML5 and about their interaction. I won't do it. So, straight to the point.The idea of creating a game for Android probably sits in the minds of tens of hundreds of developers, and those who consider themselves as such. I'm not an exception.
The whole process will be divided into several steps and the final application will consist of two parts:
- Wrapper (in this case for Android)
- A game
Step 1. Writing the game itself
Another advantage of writing a game in HTML5 is the fact that testing does not require a bunch of running programs, IDEs, emulators, and so on. All you need is a browser (Chromium in my case) and a text editor (BlueFish)The game will be simple: there is a blue rectangle and there is a green rectangle. The player's task is to drag the blue rectangle onto the green one, bypassing the red one, which moves across the playing field in an arbitrary direction.
For game development I will use J2ds (game engine).
Finished game code:
index.html
You can ignore the quality of the game code, because this is not the purpose of the article. Although, of course, you can optimize as much as you like, this process is generally probably endless.
Step 2Android Studio Creating a wrapper for the game
I'm not going to measure the coolness of this or that IDE for Android development with anyone, but I'll show you on the example of Android Studio. For work we need:- Java machine (OpenJDK is suitable for my Linux);
- Android Studio distribution.
Download, install.
Once everything is installed (These two programs are enough), launch Android Studio.
The start window will open (if it’s the first launch), if not the first one, then the IDE itself will open, but it doesn’t change the essence, let’s go to the SDK Manager:
Here you need to tick the Android versions you need with which you will work, in my case it is Android 4.4.2, you can select at least all at once.
The main thing - be sure to select "Tools" and "Extras" and click "install packages".
As soon as everything has downloaded, the IDE will start with a dull gray background and a few buttons, click the first one and create a new project. If the IDE started immediately in working condition, then: "File-> New-> New Project"
Fill in the required fields and click Next
Select the desired version of android and Next
Here we select Blank Activity (an empty template with Hello, World!)
In the next window, fill in the data for creating classes, I will not change for clarity:
We solemnly press Finich and wait until the IDE configures and prepares everything for work.
The form designer window will open. It is not the same as in Lazarus, Delphi, but there is still something similar:
Do not rush to change anything or click something, the setup is not over yet. Open "Tolls->Android->AVD Manager" to configure the emulator.
Here, if there is nothing, click "Create Virtual Device", if there is, you can not create a new one, I already had it, because I "stumbled" it while I figured it out. If you need to create a new emulator, then everything is simple there:
1. Choose the screen size and phone model
2. Choose the version of android (I have 4.4.2)
3. Set up the device.
In the third step in more detail:
T.K. the game is stretched horizontally, you need to select the landscape mode.
When all the settings are entered, click on the green triangle and start the emulator. After starting, we wait until the device is fully loaded and the OS starts:
Do not close this window, emulation will take place in it. Now you can return to the editor and change the orientation in the form designer:
You can run! Now it's definitely possible.
If you are prompted to select an emulator, you can check the box below:
Congratulations! Everything works, checked!
Minimize our emulator (But don't close it!) and go to the editor. Everything is a bit more complicated (a little bit) there.
You need to switch to the "Text" mode. In your activity_main, all the elements that are on the form are described. Including the form itself. And it's not a form at all.
Because we're making a game in HTML5, and here we just have a wrapper for the game, we remove all the text and paste the following:
Now, if you switch back to the design, it will look different:
As you can see, now instead of “Hello, World”, a WebView stretched to full screen flaunts in full. This object is our "window" to the game world.
You can even run, see if there will be a white screen. Move on.
This tab shows the structure of the project and all of its internal files and resources.
Explanation
We need to find the "manifest" file and add the following line to the "application" definition:
android:hardwareaccelerated="true"
It's time to work on the functionality of our "browser", because this is it! Open the "MainActivity.java" class and remove everything unnecessary, leaving only the main one:
Explanation
package com.soft.scanner.demogamehtml5; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; public class MainActivity extends AppCompatActivity ( @Override protected void onCreate(Bundle savedInstanceState) ( super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ) )
If you haven’t forgotten, we added a WebView in the activity_main file, pay attention to the bold line:
android:layout_height="fill_parent"
android:id="@+id/webView"
android:clickable="true"
android:scrollbars="none" />
We need to declare an object of the WebView class.
To do this, add to the list of imports:
Import android.webkit.WebView;
And then we declare our myWeb object inside the MainActivity class:
Protected WebView myWeb;
Now, after the line setContentView(R.layout.activity_main); paste the following code:
/* Find our browser */ myWeb= (WebView) findViewById(R.id.webView); /* Set up our browser */ myWeb.getSettings().setUseWideViewPort(true); myWeb.setInitialScale(1); myWeb.getSettings().setJavaScriptEnabled(true); /* Load the page */ myWeb.loadUrl("file:///android_asset/index.html");
Here's what I got in the editor:
And here's what's in the emulator:
If you feel the same way, we are on the right track!
There is little left to do:
Where we load the page in our browser, the path to the file looks like this: "file:///android_asset/index.html"
It should be noted that we can store any files inside our game, having access to them.
In our case, the key folder is "android_asset", let's create it (yes, it's not in the project by default):
“File -> New -> Folder -> Assets folder”, a window will open where you just need to agree with the IDE.
Noticed? The project has a new folder:
Right-click on it -> "Show in Files", the system explorer will open (in my case, Nautilus), pay attention to the path to the folder. Keep in mind that the folder is called "assets" but is accessed via "android_asset".
The index.html file is the same index from the beginning of this article. Well, let's try to run!
A little advice: it is best to test on a real device via USB, so the test results will be clearer, and mouse control is not the most convenient option, not to mention multiple clicks.
Step 3Android Studio Building the application and signing it
When the game is fully debugged by you (in a browser or on an emulator), the wrapper is completely ready and all development stages are over, you can build the application. Android Studio lets you build apps and sign them with your keys.To create keys in this IDE there is a special utility "KeyTool".
Let's move on to creating an executable application file ("Build -> Generate Signed APK"):
If you have not created keys and aliases before, click "Create New". You can fill in the fields at your discretion, the accuracy of the data lies entirely with you.
The first field is the path to the folder where the key will be saved. After clicking Ok, the form will be filled in automatically:
For subsequent applications, it is not necessary to create new keys, you can sign other applications with your key, this is exactly what the “Choose Existing” button is for.
In the next step, the IDE will ask you to enter the password again, and then specify the folder to save the APK file.
Now you can relax and drink, for example, coffee. The system started compiling, the result in the status bar:
After the compilation is completed, the system will notify you about it.
Now it's enough to move the file to your phone / tablet and install it like a regular application.
Result:
For an example in the LAN, if necessary.
