Many people state that kivy is slow. While this may be true it is mostly due to that python is slow to run on android devices.Thus it is in the programmer's hands to properly optimize their code so as to create a performant application.
Most of the lag on android devices runing kivy apps arise due to widget creation. Widget creation remains the slowest step in a kivy app. Here are some of the methods that I follow to optimize my apps and ensure I can hit 60fps even on old devices
One very simple method to improve performance of your app is to load all the heavy widgets or even all your apps widgets at the start of your application. However this does have the draw back of causing longer load times for your app.
The way to cover up these long load times would be too create an interesting app splash screen with some animations. Buildozer supports lottie animations(https://github.com/tshirtman/p4a_lottie_demo Courtesy of tshirtman).
Loading all your widgets at start means that you can simply add your widgets to screens through out your code and the performance impact would become negligable.
If you do need to create your widgets during program run time you can use animations to hide the lag. Properly placed animations that animate opacity can be used to hide the time required to load widgets. The user would perceive this just as a transition and not as lag.
You can take this further if you have to load mutiple instances of the same widget. Rather than loading them all together. Load one widget and on its animation complete load the next one. Keep the animation duration's short so that they dont add up to become too long
| """ | |
| Loading multiple instances of a widget over a period of time to prevent lag. | |
| Useful for more complex widgets than just a button. | |
| """ | |
| from kivy.app import App | |
| from kivy.lang import Builder | |
| from kivy.clock import Clock | |
| from kivy.uix.button import Button | |
| from kivy.animation import Animation | |
| KV = ''' | |
| GridLayout: | |
| id:container | |
| cols:5 | |
| rows:20 | |
| ''' | |
| class MessengerApp(App): | |
| counter = 0 | |
| def build(self): | |
| self.kv = Builder.load_string(KV) | |
| return self.kv | |
| def on_start(self): | |
| Clock.schedule_interval(self.btn_create,0.3) | |
| def btn_create(self,time): | |
| if self.counter<50: | |
| btn = Button(text = str(self.counter)) | |
| btn.opacity = 0 # Set the opacity of the button to 0 | |
| self.kv.add_widget(btn) # Add the button | |
| Animation(opacity = 1, duration = .25).start(btn) # Duration is < than clock duration | |
| self.counter +=1 | |
| if __name__ == '__main__': | |
| MessengerApp().run() |
By default when you create a widget. Kivy will create the entire widget within a single frame. But if your widget is complex and has numerous widgets and layouts within it this can cause lag. This is because kivy will be holding back from displaying that frame until the widget is entirely created which will appear to your user as the program freezing or hanging.
For certain cases using a loading bar to depict that the app is in fact still running but just loading data is useful but not pleasing. It makes the user wait for the app to complete its operation which can be frustating. There has to be some sort of visual action.
Instead you could slowly load instances of your widgets over multiple frames. Basically the code works in a way where you would create a widget in a frame and then the next instance in the next frame and so on. Thus large quantities of data can be loaded quickly.
Check this link for more info (https://blog.kivy.org/2014/01/producerconsumer-model-in-kivy/)
Note: This method is only effective if you have to load a large amount of simple widgets. If you have to load complex widgets I would suggest using animations like in method 2. Or else you could break your complex widget into smaller simpler ones and load them over multiple frames.
This is a really painful task to do but definitely worth it. If you can remove un-needed layouts and widgets you can significantly improve the performance of your apps.
Some tips:
text_to = '''[font=Roboto-Black.ttf][size=18sp][color=' +self.rgb2hex(self.text_color) + ']' +
a[0] +
'[/color][/size][/font]' +
'\n' +
'[font=Roboto-Regular.ttf][size=16sp][color=' +self.rgb2hex(self.secondary_text_color) +']' +
a[1] +
'[/color][/size][/font]'''
This is an example of combining two completely differnet labels into a single label object. I pass the text as this string and when displaying it would appear as they are separate labels but in fact they are a single label. This in some cases can cut the amount of widgets to create in half.
There is no way to update the user interface or create widgets in a thread as kivy doesnt garuntee stable behaviour in this way. Instead run your ui on your main thread and run your other app functions on a secondary thread. This if done properly and for the correct use case can be very effective in improving performance.
Check here for info on python threading in a simple way: (https://www.geeksforgeeks.org/multithreading-python-set-1/)
This method can be used to signifcantly increase your app load times on android. It works by loadig only the mainscreen and then slowly loading the other screens of your app over time. The code is by @Kulothungan16 ... Check his repo for more info (https://github.com/Kulothungan16/kivy-lazy-loading-template)
import kivy
Correct:
from kivy import #Whatever you need to import
Animation(opacity = 1, d=.3, step = 1/30)
good post indeed, so for number 6 which is lazy loading i tried, it seems good and is fast but you cant use it for complex code as it load screen to a point if in your current project you used something like MDBottom Navigation you wont be able to load screens inside it or above it, but it is good, i believe if the owner could improve the code it will help many people out there, and other thing about lazy loading is that in android, is hard to use custom back button as i tried many times when you press your app back button to navigate back on previous screen it wont work at all🤞, but at the moment am trying to use kivy_router to implent lazy loading as it seems to have its own build it navigation which might work in android,
good post indeed, so for number 6 which is lazy loading i tried, it seems good and is fast but you cant use it for complex code as it load screen to a point if in your current project you used something like MDBottom Navigation you wont be able to load screens inside it or above it, but it is good, i believe if the owner could improve the code it will help many people out there, and other thing about lazy loading is that in android, is hard to use custom back button as i tried many times when you press your app back button to navigate back on previous screen it wont work at all🤞, but at the moment am trying to use kivy_router to implent lazy loading as it seems to have its own build it navigation which might work in android,
Thank you for your words. Its been long since I have used Kivy, I will update this guide with some more methods and like you suggested some better code when I find the time
Thank you for thsi post ,really helpfull