I think, Whoever has worked with the stack trace, can help me?
I'm trying to analyze my systrace, to find the causes of frozen frame issues.
I see this - https://developer.android.com/studio/profile/inspect-traces#events-table
where all call for a selected thread is shown, and I think, It'll be helpful.
But I can't see it my systrace, How can i enable it?
The Events tab should appear after you selected one or more threads.
I have a module here that has the job to smooth some UI output. It is fed by data that is timestamped. The module itself has a timer that, along with lots of code, makes sure that on the other end there is a nice visual result.
But sometimes, the whole thing gets stuck. Its extremely hard to reproduce and so far i could narrow down some things.
1) the input is still working and fine
2) the device is still responsive
So somehow the logic of the smoothing has a bug that under certain conditions hangs the thing up. I logged all "returns" because its still drawing stuff, but the values dont seem to change, so the chain has to be cut off somewhere.
Every return statement in the code makes sense and they are called every once in a while for legitimate reasons and they dont break the code. But there has to be a combination of events/things/values that break it.
The code itself is poorly written (by some intern, who now has no clue what he did back in the day), almost no documentation and i have a HARD time understanding the code and im not a dummie.
The module "works" and we dont know if the bug has been there always or if it was introduced one day by some other changes. Time is pressing, unit testing is nonexistant.
I know it should be different, but thats just real life.
Now there's always the rewrite... But how could i first try to narrow down on the bug and maybe save myself a lot of trouble and just FIX it with some quick-n-dirty ?! (maybe its not even dirty at all and i just fix the missing 1% to 100% working)
I have no experience with unit testing and i dont really know what kind of time we are talking about to set up a test in this case. I am far beyond the ideal conditions, its more like Schwarzenegger in the movie Predator.
Any help is welcome.
In my experience, sometimes it takes much more time understanding and reverse engineering someone else's code, than writing your own version from scratch. In the past I've decided to rewrite complete programs myself, reducing the code sometimes by 80% and resulting in much more elegant and readable code. This might be impossible if we're talking about a huge project.
Some important things to have in mind though are:
- do you know the algorithm, or would you first have to reverse engineer it
- is rewriting the code doable with your skills in a reasonable time
- do you need to maintain the code often
Also, if the code was written by an inexperienced programmer, chances are that you'll find more bugs in the future.
It is impossible to give you precise advice, with the little information you give us. Use your best judgement, rewrite parts of the code if possible, split the code in different classes, modularize, rename variables, clean it up... and the bug will probably become much more evident.
I am new to Android SDK/API environment. It's the first I am trying to draw a plot/chart. I tried running different kinds of sample codes on the emulator using 3 different free libraries, nothing is showing on the layout screen. The logcat is repeating the following message:
W/Trace(1378): Unexpected value from nativeGetEnabledTags: 0
I/Choreographer(1378): Skipped 55 frames! The application may be doing too much work on its main thread.
The problem didn't persist and the chart worked when I ran a sample code pertaining to an evaluation copy of a licensed library.
taken from : Android UI : Fixing skipped frames
Anyone who begins developing android application sees this message on
logcat “Choreographer(abc): Skipped xx frames! The application may be
doing too much work on its main thread.” So what does it actually
means, why should you be concerned and how to solve it.
What this means is that your code is taking long to process and frames
are being skipped because of it, It maybe because of some heavy
processing that you are doing at the heart of your application or DB
access or any other thing which causes the thread to stop for a while.
Here is a more detailed explanation:
Choreographer lets apps to connect themselves to the vsync, and
properly time things to improve performance.
Android view animations internally uses Choreographer for the same
purpose: to properly time the animations and possibly improve
performance.
Since Choreographer is told about every vsync events, I can tell if
one of the Runnables passed along by the Choreographer.post* apis
doesnt finish in one frame’s time, causing frames to be skipped.
In my understanding Choreographer can only detect the frame skipping.
It has no way of telling why this happens.
The message “The application may be doing too much work on its main
thread.” could be misleading.
source :
Meaning of Choreographer messages in Logcat
Why you should be concerned
When this message pops up on android
emulator and the number of frames skipped are fairly small (<100) then
you can take a safe bet of the emulator being slow – which happens
almost all the times. But if the number of frames skipped and large
and in the order of 300+ then there can be some serious trouble with
your code. Android devices come in a vast array of hardware unlike ios
and windows devices. The RAM and CPU varies and if you want a
reasonable performance and user experience on all the devices then you
need to fix this thing. When frames are skipped the UI is slow and
laggy, which is not a desirable user experience.
How to fix it
Fixing this requires identifying nodes where there is or
possibly can happen long duration of processing. The best way is to do
all the processing no matter how small or big in a thread separate
from main UI thread. So be it accessing data form SQLite Database or
doing some hardcore maths or simply sorting an array – Do it in a
different thread
Now there is a catch here, You will create a new Thread for doing
these operations and when you run your application, it will crash
saying “Only the original thread that created a view hierarchy can
touch its views“. You need to know this fact that UI in android can be
changed by the main thread or the UI thread only. Any other thread
which attempts to do so, fails and crashes with this error. What you
need to do is create a new Runnable inside runOnUiThread and inside
this runnable you should do all the operations involving the UI. Find
an example here.
So we have Thread and Runnable for processing data out of main Thread,
what else? There is AsyncTask in android which enables doing long time
processes on the UI thread. This is the most useful when you
applications are data driven or web api driven or use complex UI’s
like those build using Canvas. The power of AsyncTask is that is
allows doing things in background and once you are done doing the
processing, you can simply do the required actions on UI without
causing any lagging effect. This is possible because the AsyncTask
derives itself from Activity’s UI thread – all the operations you do
on UI via AsyncTask are done is a different thread from the main UI
thread, No hindrance to user interaction.
So this is what you need to know for making smooth android
applications and as far I know every beginner gets this message on his
console.
As others answered above, "Skipped 55 frames!" means some heavy processing is in your application.
For my case, there is no heavy process in my application. I double and triple checked everything and removed those process I think was a bit heavy.
I removed Fragments, Activities, Libraries until only the skeleton was left. But still the problem did not go away. I decided to check the resources and found some icons and background I use are pretty big as I forgot to check the size of those resources.
So, my suggestion is if none of the above answers help, you may also check your resource files size.
I too had the same problem.
Mine was a case where i was using a background image which was in drawables.That particular image was of approx 130kB and was used during splash screen and home page in my android app.
Solution - I just shifted that particular image to drawables-xxx folder from drawables and was able free a lot of memory occupied in background and the skipping frames were no longer skipping.
Update Use 'nodp' drawable resource folder for storing background drawables
files.
Will a density qualified drawable folder or drawable-nodpi take precedence?
Another common cause of delays on UI thread is SharedPreferences access. When you call a PreferenceManager.getSharedPreferences and other similar methods for the first time, the associated .xml file is immediately loaded and parsed in the same thread.
One of good ways to combat this issue is triggering first SharedPreference load from the background thread, started as early as possible (e.g. from onCreate of your Application class). This way the preference object may be already constructed by the time you'd want to use it.
Unfortunately, sometimes reading a preference files is necessary during early phases of startup (e.g. in the initial Activity or even Application itself). In such cases it is still possible to avoid stalling UI by using MessageQueue.IdleHandler. Do everything else you need to perform on the main thread, then install the IdleHandler to execute code once your Activity have been fully drawn. In that Runnable you should be able to access SharedPreferences without delaying too many drawing operations and making Choreographer unhappy.
I had the same problem. Android Emulator worked perfectly on Android < 6.0. When I used emulator Nexus 5 (Android 6.0), the app worked very slow with I/Choreographer: Skipped frames in the logs.
So, I solved this problem by changing in Manifest file hardwareAccelerated option to true like this:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.myapplication">
<application android:hardwareAccelerated="true">
...
</application>
</manifest>
Update Jan 2022. According to the comment from #M.Ed: Hardware acceleration is enabled by default if you're targeting APIs >= 14.
Try to use the following strategies in order to improve your app performance:
Use multi-threading programming if possible. The performance benefits are huge, even if your smart phone has one core (threads can run in different cores, if the processor has two or more). It's useful to make your app logic separated from the UI. Use Java threads, AsyncTask or IntentService. Check this.
Read and follow the misc performance tips of Android development website. Check here.
I am not an expert, but I got this debug message when I wanted to send data from my android application to a web server. Though I used AsyncTask class and did the data transfer in background, for getting the result data back from server I used get() method of the AsyncTask class which makes the UI synchronous which means that your UI will be waiting for too long. So my advice is to make your app do every network oriented tasks on a separate thread.
I had the same problem. In my case I had 2 nested Relative Layouts. RelativeLayout always has to do two measure passes. If you nest RelativeLayouts, you get an exponential measurement algorithm.
Optimize your images ... Dont use images larger than 100KB ... Image loading takes too much CPU and cause your app hangs .
this usually happens when you are executing huge processes in main thread. it's OK to skip frames less than 200. but if you have more than 200 skipped frames, it can slow down your application UI thread. what you can do is to do these processes in a new thread called worker thread and after that, when you want to access and do something with UI thread(ex: do something with views, findView etc...) you can use handler or runOnUiThread(I like this more) in order to display the processing results.
this absolutely solves the problem. using worker threads are very useful or even must be used when it comes to this cases.
https://stacklearn.ir
I had the same problem. When I ran the code on another computer, it worked fine. On mine, however, it displayed "The application may be doing too much work on its main thread".
I solved my problem by restarting Android studio [File -> Invalidated caches / Restart -> click on "Invalidate and Restart"].
My app had same problem. But it was not doing other than displaying list of cards and text on it. Nothing running in background. But then after some investigation found that the image set for card background was causing this, even though it was small(350kb). Then I converted the image to 9patch images using
http://romannurik.github.io/AndroidAssetStudio/index.html.
This worked for me.
In my case, it was because I had accidentally set a breakpoint on a method. Once I cleared it, the message went away and performance improved a lot.
As I did first preferably use SVG images instead of all other types, If not possible compress all of your PNG and JPG resources using some image processing tools such as Adobe Photoshop or Fotosizer. one of the easiest ways is online image compressing tools like this which helped me to decrease all my image files to almost 50% of their initial size.
This is actually not a problem. This happens when you have the debugger for a long time. Remove the brake point and check again.
I got same issue while developing an app which uses a lot of drawable png files on grid layout. I also tried to optimize my code as far as possible.. but it didn't work out for me.. Then i tried to reduce the size of those png.. and guess its working absolutely fine.. So my suggestion is to reduce size of drawable resources if any..
After doing much R&D on this issue I got the Solution,
In my case I am using Service that will run every 2 second and with the runonUIThread, I was wondering the problem was there but not at all.
The next issue that I found is that I am using large Image in may App and thats the problem.
I removed the Images and set new Images.
Conclusion :- Look into your code is there any raw file that you are using is of big size.
First read the warning. It says more load on main thread. So what you have to do is just run functions with more work in a thread.
Have not resolved yet but will do. For my tiny project with one composable function (button) and logic to check if "com.whatsapp" packages exists on device (emulator) i have the following in the same log while starting simulator:
I/Choreographer: Skipped 34 frames! The application may be doing too much work on its main thread.
For me that was RoundedBackgroundColorSpan ! in textview, I remove it so (burn my brain to find it because It doesn't appear in real smartphones like Pixel 4 Xl or Samsung note 10+ also in emulator but in chip device this slow a view).
This is normal if you are using async/await functionalities in your application.
This question already has answers here:
Meaning of Choreographer messages in Logcat [duplicate]
(5 answers)
Closed 8 years ago.
I am building a new game with andengine and for some reason i keep getting this debug statement in the logcat:
01-31 21:29:50.503: I/Choreographer(697): Skipped 152 frames! The application may be doing too much work on its main thread.
Im not really sure what is causing this error exactly during my game. I am checking a lot of collisions, but they arent initiated until after the game play scene has started.
I also noticed on my galaxy S3 the game causes my phone to "flicker" when swiping changing home screens and pulling down the task bar at the top.
I think this error has something to do with it, but i am not sure. What do you guys think?
Also each time the user goes to another level i initialized the collision detectors all over again. But i dont unregister or stop the last collisions that were started. I thought they would be automatically cleaned up when the new one is initialized.
What do you guys think?
It sounds like you're aware of what the message is telling you, i.e., your frame rate is lagging. Your follow up question, "why?" is going to be impossible to answer without more information. You've provided some possibilities: is it the collision handling? Is it processing of unnecessary collisions? Is it some problem in the scene transitions? The answer is, maybe. Maybe it's any of those things. Maybe it's something else. At the moment all we can do is guess, because we're not looking at the code.
But the good news is, you're not without recourse! What you need to do is test your code and find where the bottlenecks are. A good place to start is to throw in some calls to clock the milliseconds between blocks of your code that you suspect are the problem. You may discover that things you'd assume we're slow are actually happening pretty quickly, and conversely, things you thought were fast are happening slowly. Focus on the latter! Put more calls in there to see where exactly things are taking longer. And look at your code to see why it might be running slowly there. Are a lot of objects being instantiated there? Is it reading from disk? Etc.
When you're ready for them, there are some great third party tools to get deeper into the testing, but it's worth spending some time to clock and review your own code first. You have the advantage as the author of suspecting where the problems may be. Start investigating!
Side note, I'd provide some links to third party tools, but I'm writing this from a jacuzzi. I'll update later.
I’ve been working on building a nice graphical selector for an Android project. Unfortunately, this selector is causing me lots of frustration due to a deadlock in the application’s UI thread. Parsing and rendering the various SVG layers that make up each clock is a relatively expensive operation. Locking up the user interface while doing these operations is clearly bad design, so I'm trying hard to give good feedback.
The selector consists of two columns, an image of the clock on the left and the name of the clock on the right. Using the standard ListActivity support, the goal is to show an indeterminate progress image in the left column until the clock layers have been loaded and rendered. At that point, the animated progress image is hidden and the clock image is displayed.
The implementation is simple in concept. The list adapter subclasses the standard BaseAdapter implementation to provide an implementation of the getView method. The getView method delegates loading of the clock’s image to an asynchronous executor service, keeping the user interface alive. When the asynchronous task completes, it posts a runnable to the UI thread to hide the progress indicator and show the image view. There is logic related to properly handling recycled item views as well.
While this is mostly working, I’m hitting a random deadlock condition that locks up the UI thread, usually resulting in an “Application Not Responding” (ANR) error message to the user. All of my attempts to diagnose and resolve this issue have ended with nothing but frustration. So far, I’ve tried all of the “standard” approaches to diagnose this:
Analyzed the traces.txt file generated by the ANR.
Unfortunately, the process never shows up in the log file.
Force-generated a traces.txt file using kill SIGQUIT pid while the application was still running. Again, the process doesn’t seem to show up. Instead, I see “W/dalvikvm(19144): threadid=4: spin on suspend #1 threadid=9 (pcf=0)” whenever attempting this.
Enabled kernel-level deadlock prediction, but it never showed anything
Attempted to use the standard Eclipse debugger to suspend the UI thread once it is locked up.
No big surprise that it did not work. Added lots of Log output trying to pinpoint the hang. At least from that logging, it doesn’t appear to be a hang anywhere directly in my code.
I even tried to use method tracing to see if I could figure anything out.
At this point, I’ve run out of good ideas on how to track down and fix this problem on my own. I've removed all synchronization in my code and I'm still hanging up, implying some kind of hang in the underlying platform code. Without a stack trace, I'm truly flying blind at this point. Can anyone offer any ideas?