I built an android application and am I now in the testing phase. I tested my application on the following 2 devices:
Sony Xperia Z3
One Plus One
Both devices have the same processor and ram, but the performance on Sony Z3 is laggy whereas on OnePlus One it is smooth. I looked up about this on google but I couldn't find an answer.
Is there a reason for this behaviour?
The reason why Android applications lag on the devices may have various background. If the UX of your app suffers from lagging it's worth learning tools that Android Studio comes with. This is my suspicion based on your description but I suggest focusing in particular on Method Profiler as it will immediately indicate the causes of lags. Mostly probably there are some heavy calculations executed or massive objects creation performed on the UI thread.
Alternatively, the following libraries will help you with detecting sensitive places that the application's performance may suffer from:
https://github.com/brianPlummer/TinyDancer
https://github.com/square/leakcanary
Pretty good working example below:
https://github.com/artem-zinnatullin/qualitymatters
Related
I am making a Flutter app that plays videos using youtube_player_flutter.
It was completed for the time being, but when I tried running it on the Android emulator, it was a behavior that clearly felt strange. Looking at Flutter performance, it was 5-10fps.
This is hopeless.
However, when I run it on the actual iPhone, there is almost no discomfort at 30-60fps.
I'm not sure what caused this difference, but I can think of it as my mac book isn't big (not high spec) and often runs out of memory.
After all, does the performance of the emulator depend on the capacity of the running computer?
So, even if this phenomenon actually occurs, if I change the computer, the performance will change, and the behavior on the actual Android device will not necessarily match the behavior on the emulator that can be confirmed at present?
We have developed a react-native (v0.17.0) application for both iOS and Android. The iOS version is very responsive on physical devices. On Android devices I see a tremendous amount of variability. On Android version 5.1 the app is super responsive. On two separate phones with 5.1.1 (and both phones with much better specs) it is highly unresponsive. The navigation takes at least five seconds, TouchableHighlight buttons sometimes do not register at all. I have of course turned off dev mode but the issue still persists. My issue is that I can't see the degrade in performance on the emulator and this makes it hard to pin down the issue. Has anybody experienced and fixed a similar issue? What would be an advisable way to pinpoint the issue?
Disabling dev mode should help on android because it is super slow.
There are a little lack of details about what you are using or doing in your app. But i also had some performance issues in the app and could find the reasons for those by using the sysTrace wich is explained in the following link
https://facebook.github.io/react-native/docs/android-ui-performance.html
Maybe you can take advantage out of this.
I am an experienced Apple developer who is looking to develop for Android. I do not currently own any Android devices, so I am considering purchasing a B&N Nook HD for development purposes, which now runs Android. From the research I've done, it seems that the spectrum of Android devices is quite varied and disorganized compared to the Apple world (no offense intended). So, my question is, even though there are better (more expensive, too) devices to purchase (Nexus tablets), will a Nook HD suffice for beginning Android development? By the way, my intentions are to develop mostly tablet utilities with emphasis on networking and data manipulation. I'm not really interested in hardware-specific areas like graphics and sensory input (with the exception of the touchscreen, of course). Thank you for your advice.
In a general sense, yes. Your device will do just fine. However, a caveat is that you must take into consideration the flavor of android you are planning to target. e.g. Working on a Froyo flavor won't necessary guarantee it will run on the latest Jellybean and so on.
Hell, I started developing android almost 2 years ago (but stopped indefinitely) but it was only this year that I took it upon myself to get a PHYSICAL android device when I continued to develop my app. For no particular reason I just dropped by the local gadget mall and randomly picked the Samsung Tab 3. Yes, reviews are bad and it kernel panics a lot but these are trivial things for my specific use.
The one major problem I had? Dealing with REAL input from REAL data on a REAL device. My app worked sufficiently fine on the emulator. When it ran on the Tab it was breaking everywhere!
This is related to question Android Emulator vs Real Device
What is the current state of art of Android emulators and what are the differences that developers should be aware of. I'm working on an app that uses bluetooth and thinking of adding a feature related to phone calling. Since I can't afford to test on all real devices so what should be the guidelines for developer to test such apps on emulators ?
Genymotion rocks. According to the blog post of Cyril Mottier it is even much better then the hardware devices.
http://www.cyrilmottier.com/2013/06/27/a-productive-android-development-environment/
I test basically everything on several real devices. The only thing I use an emulator for is making sure layouts look good on the configurations I don't have available(I don't have a 7" tablet, for instance). This is only after just about everything else is done.
Functionality is going to be nearly the same on any real device, and the emulator is no guarantee, since it doesn't seem to act like any real device in some cases(openGL, for instance).
Testing usability on a desktop with a mouse just doesn't make sense, unless you're writing something that going to be using that input method. There's a big difference between swiping with a finger and click-dragging with a mouse.
Even if you have the fastest emulator/virtualizer in the world, how can it be any faster than just picking up the phone next to you?
I've got an app out for Android that generates sound.
When the CPU is over worked, it doesn't run a tight enough loop and the result is snaps, crackles, and pops in the audio.
I was thinking that with newer devices, there would be less of this.
But it looks like on the tablets and newest phones, where I would expect better hardware and smoother audio, it usually seems to be worse than my old old Droid and Android 2.2.3.
I've got some more testing to do (I usually test this stuff in a Verizon or AT&T store as I can't afford all that hardware myself), but this seems to be the case so far.
What I'm wondering is there anything specific from Android 2 to Android 4 that could account for this?
For example a "governor" that limits how fast a Thread can run.
The loop is running in the run() of a subclass of Thread. It's created in an Activity (as opposed to a Service).
I would post the name and a link to the app (it's free) but I'm afraid that would probably be viewed as spam, or at least improper etiquette.