We Keep Coding

setImageResource() programmatically to multiple ImageViews cause crash

I have 15 ImageViews created in the XML file and I have to set the images of them programmatically.
I have tried this code to do so:
imageView1.setImageResource(R.drawable.imageOne);
And it works fine until I try to do it with all 15 ImageViews:
imageView1.setImageResource(R.drawable.imageOne);
...
imageView15.setImageResource(R.drawable.imageFifteen);
Now the application crash when it tries to load the view, because of the code above. And I get this weird message: I/Choreographer: Skipped 46 frames! The application may be doing too much work on its main thread.

I think you are using scroll view, which is not supported to reusable views. If you want to create multiple imageviews and setting an images then you should use listview/RecyclerView etc which supports reusable view. Try to read about reusability.
Your application may also crashed because of you are loading large image which is requires more memory to show. Read about:
https://developer.android.com/topic/performance/graphics/load-bitmap.html

Maybe you are delegating too work to MainThread so try to do it in a different way.
Use multi-threading programming if possible. It's useful to make your app logic separated from the UI. Use Java threads, AsyncTask or something similar. Check documentation

Skipping frames after preparing jsoup connect [duplicate]

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.

Android/Java decisions about threading

Okay, so I after playing around with the Android SDK a little I have decided to develop a full application. Not necessarily to release on the store (I don't really have the tools at my disposal to do proper QA and so wouldn't feel right; I could only test on my one personal device) it is mostly just a personal project for fun and learning. In the end, I decided on a camera application because I use my camera fairly often so it is the kind of application I would end up actually using if I made it and also because I am quite excited by the features of the new Camera2 API in Android L and want to give them a try.
Anyway, I have been thinking on the design/architecture of the application for a while and I have come across a potential problem that I cannot really resolve myself as I am not only not really familiar with GUI programming of this nature but also not 100% on Java and the Android SDK. They both sit well outside the purview of my dayjob.
Now I know enough that I really need to keep my UI thread separate from everything else, but what I am unsure about is first of all, what I should devote extra threads to (I was thinking one to handle image capture and storage, and another to handle the settings? perhaps that is over doing it) and also whether to have background threads which the UI thread communicates with through Events or simply to spawn threads as and when they are needed. Perhaps a single intermediate background thread which arbitrates between the UI thread and any background processing that needs to be done? What I mean to ask is, how do I decide these things? Are there general/best practices?
I'm really asking because I want to get this done properly and plan out the application thoroughly beforehand since in the past I have found that if I just dive right in I get confused very easily and end up losing faith and dropping the project. I hope somebody can help. It's not a question that I have found easy to phrase in such a way that Google would provide satisfactory results.

I think you might consider thinking about it this way:
The UI thread is where most stuff runs. It is also, occasionally, called the "main" thread, because it is, uhhh... the main thread.
Unless your program is wildly complex, you probably don't need to worry about an architecture for threads. All you need to worry about is getting slow stuff off the UI thread. That's it. You don't care where they go, just not the UI thread.
If you buy that, there are some nifty choices:
Intent Service: If, a bit metaphorically, the methods you need to run in "background" have void return types, an intent service is the perfect solution. You communicate with it using Intents and, since it has only one thread, tasks you submit to that thread are run in order.
AsyncTask: These are fraught with problems but people get a lot of programming done with them. They run in a pool of around 6 threads, but (surprise!) run in order anyway.
Your own Java Executor: Use this if you need behavior similar an AsyncTask, but with more control.
New thread per task: Just don't do this. Really.
In any of these cases, though, you don't really care on which threads your tasks are running. You make a policy about the number of threads that makes sense on the target device and then run your slow stuff on one of them.
...and "slow" should include all I/O: databases, file system, network, etc., as well as major computation.

You want to keep things as simple as possible. You don't need a thread to set settings, and you don't need an intermediary thread. These things are only going to create unnecessary complication. You only need to take long running operations off the UI thread.
Take a look at the structures the Android framework provides to make multi-threading easier first. This will help simplify your application. These would include IntentService and AsyncTask. If those won't meet your needs take a look at the java.util.concurrent package. Using a raw Thread is often not advisable.
Another library that could come in handy is an Event Bus like Otto. This will prevent memory leaks that can occur with using AsyncTask.

You dont need to worry about threads when it comes to image capture. When you want to take a picture you do so by opening the Camera App on the device. Here is a good way of doing that.
Android SDK provides Asynctask which does things for you in the background thread, like a network call and updates the UI once its done.
You can also use an IntentService, which runs even if you exit the app and does things like upload/download without the user having to worry about it. Loaders are useful when the underlying data often changes and you need to update UI quickly (searching contacts in autocomplete text for example).
http://www.vogella.com/tutorials/AndroidBackgroundProcessing/article.html
Refer to this tutorial, its a good start. Hope this helps.

Android App taking up a lot of memory

While working on my Android application, I recently check a task manager to see how memory my application is racking up.
Right now my application has two ad banners being executed by AdMob services and then an interface fragment for a Google Map. Aside from all that I then have a menu in which I utilize a container to which I add views to it in Java code. I prefer this over a list-view as it is more light weight and easier for me to structure what I want to do with the views (and I can use Androids native animation system when adding/removing the views).
The views being added to the container are being added by a loop structure based on conditions. The views in their interface structure also have a small image-view utilizing a small local drawable.
All of this is somehow adding up to my application 44.8 MB in memory which seems abnormally high from previous development numbers. This is also the first time I decided to use the container to add views through a loop rather then the adapter with list-view method.
Can anyone tell right off hand why my application is taking up so much memory right off? This is my first time utilizing all these components: AdMob Banners, Google Maps, and Containers with added Views.
My LogCat shows no warnings of doing anything inefficiently. Just curious to see if I am doing anything wrong. If anyone has any ideas I am open to provide any source code.

I think 44.8Mb is pretty normal for a modern Android application. My bet is on Google Maps since it's very resource-consuming library (both CPU-wise and memory-wise). Anyway, you can try to sequentially remove each of the component out of app and see how it affects memory footprint.

As Andrey have already said, 44.8Mb is not too much for an Android application. But you can use DDMS to track allocations and heap updates to see exactly is taking up this memory. See this: https://developer.android.com/tools/debugging/debugging-memory.html
Besides, I would recommend using a ListView with adapter because items in ListView can be recycled, which can improve performance considerablly (See this tutorial).

Android: Preventing long-initializing app from being killed

I've been working on an app, and it's came long great. I have a problem though, Android, being greedy with its resources, loves to kill the app when I put it in the background. This is very bad, because the app is actually intended to be an AI assistant, and having to reinitialize every-time I need to use it means that it's not going to be very helpful in a real work environment.
I investigated ways to prevent reinitialization of the AI's brain, however, none of the methods have been very fruitful. Saving the instance of its brain will not work, because the POS models that she needs to operate can't be serialized. And employing a service won't work either, because if I want to communicate with the activity via the service, I have to reinitialize it along with the activity (correct me if there is a way around this, I just notice most tutorials put service.start() in the onCreate methods)
Is there a way around this? I only need to preserve the POS models. They take a while to load in for some reason despite only being a few megabytes.
Please note that this is to prevent data from being killed. There are no background processes that need to be ran.

You need to set a Notification to tell Android not to release your resources.
See this question: How can we prevent a Service from being killed by OS? . While the question itself is not directly applicable the answers have a lot of overlap with this issue.
You should probably be using a Service if you want to run things in the background though as Activities are only supposed to run when you have a layout in the foreground. You could store your required object in the service, grab it as necessary when (re)starting an Activity that requires it and update it when your Activity loses focus.
Edit: I accidentally pasted the wrong link. Now corrected.
Also, have a look at this Android resource if you have not already: http://developer.android.com/training/basics/activity-lifecycle/recreating.html