Adobe AIR Development

[Bullety]

Hi,

this is more a general question but also regarding the Air development for the Playbook and further BB10 devices.

My Playbook has some huge performance problems when it comes to scrolling lists.

And this problem exists with nearly every app (not the ones I developed).

For example, have a look at the NTV app - its such bad, its nearly unusable because it is so much lagging when scrolling lists.

I don't know how this app was developed but I assume it is Webworks or Air.

You can see this lagging also in the official Facebook app - its the same bad performance when it comes to scrolling.

I assume this Facebook app is also WebWorks or Air.

So is Air or WebWorks usable at all?

This performance does not make fun and it does not make sense to develop applications with this platforms if these performance issues are platform based.

My question is now, is it true that the only platform which really "works at all" (regarding performance) is the native "platform"?

Or is this a problem in the current Playbook OS version?

Did anyone else notice this performance issues when scrolling lists?

Thanks,

Bullety

[jtegen]

The genereal response is that it all depends on the type of app. If scrolling long lists is your app, then you have to look at how the list is being managed. Personally, I have not had performance issues with long lists and scrolling (hundreds of items in a list). We have provided very complicated apps that do a lot of graphics and have not had a lot of issues either. True, you will maximize performance with the NDK/Cascade, but there is a price involved with that (C++ complexity, incomplete API, lots of different libraries to glue together, lack of samples, etc.). It all comes down to what language are you most comfortable with and what your application needs to do.

[Bullety]

Thanks for your message jtegen.

Well, I must say that I even got problems with App World.

The Playbook "itself" is fast, scrolling the apps list is fast etc.

But even the App world main screen lags when I scroll the apps (12 app pictures in this horizontal list).

And it is so slow that it simply does not make fun at all to use it.

So I wonder how this app is built.

If App World is built with Air and Air is simply as slow as this on the Playbook, it would be a reason for me to not use Air at all.

But if it is built with the NDK, I wonder where the really bad performance comes from.

Do you also have this performance problem even with the App World app?

[taylortbb · Accepted solution]

It's an AIR issue, specifically software rendering. All the apps you've listed are AIR. Try out something like Scrapbook and you'll see how smooth things can be (it's Cascades).

I haven't seen the same issues when using WebWorks with Sencha Touch. It's also very possible to make things smooth in the NDK with Cascades, but that's only for BB10 (for non-RIM devs). So you can't use it on the PB until BB10 is released (late 2012).

I'll also note the newer QNX fuse UI components are much smoother than the classic QNX UI components. If you must use AIR make sure you use them.

[Bullety]

Hi taylortbb,

Thank you, this helps me.

You are correct, Scrapbook works like charm but of course, this is NDK.

I checked the Sencha Touch examples and they are working pretty smooth (opposing to the other AIR apps I described).
So WebWorks will be the better choice to use.

Thanks again, so I'll start using WebWorks again.

[pyth]

I also have to say - using AIR with the BlackBerry components is no fun. I spoke to a few users about the performance of lists, and luckily many don't even notice. But as developers, it's true, it's no fun because you can see the lag.

When you use a list in AIR, even a list with 50 entries shows a huge lag. You can use a lot of tricks, see here: http://supportforums.blackberry.com/t5/Adobe-AIR-Development/Scrolling-issues-on-PlayBook-device/m-p... the entry dates back to May 2011. But it's still not the optimal solution.

It's sad to say it, but any App with lists/scroll panes I made, if I had the time/chance to redo them, I would, but only with NDK. Not even WebWorks because personally I also saw some lagging there. The hope of better performance is with Cascades.

[Acenet]

Hello guys,

  no offense, but I don't agree at all with what is said in this post.

AIR is quite good rendering lists, I see no lag with optimized item renderers and quite big list. Actually list size is not an issue if you use virtual renderer. I'd say it's just all about optimization, whatever the language.

[Bullety]

Hmmm...Acenet, even most the apps that come with the Playbook are not working well - so there may be a general Problem in the current Playbook OS?

[georg22]

Its not a problem of the Playbook OS. Nearly every app, which comes with the playbook is an AIR app. Its because AIR was the first platform available for playbook development. And while AIR is a powerful framework, there are performance issues, i think , because it needs a runtime and its single threaded and most of it is vector rendring, which is slow too.

But it is possible to get good - not perfect - scrolling performance if you make use of some tricks.

I think it depends on the app you want to build. If the core element of your app is a list (for example a twitter app), then Cascades might be the best. Or even Webworks. When it comes to animations, vector graphic etc. (for example a clock app, charting, or a game) AIR offers great APIs and tools and a mature programming language. Webworks is good for small or content-centric projects, imho. 

Cascades has a very limited API for now. There is, for example no build in drawing API, so you need to use openGL. You cant define simple shapes with QML and so on. The current QML is limited and you need to mix it with c++ code when you wani to do something special int the UI. And the documentation is very basic.

I will wait for the next version of Cascades, or even Qt5, which offers great things like shader, 3D-animations etc. out of the box. 

On the other hand, i think that the new BB10 devices will run AIR list-controls faster, because of the faster processor, so maybe the performance-problems will go with time.

[jtegen]

I agree with georg22. NDK/Cascade is not very mature in terms of an API and integrated functionality. You have to come up to speed in a lot of different technologies and APIs and glue all that together. I too will wait for the NDK/Cascade to mature (~a year) to see if it can do better than AIR. Additionally, if RIM does not succeed with the BB10 phones, my investment with AIR is saved and can migrate over to Android and iOS a lot easier than NDK/Cascade. If QT integrates better with the NDK, that might be the best bet as well.