How to Use UiApplication.activate() in BlackBerry - blackberry

Question

I want to use the UiApplication.activate() method in BlackBerry. In Android, we use the onResume() method; so how do we use the UiApplication.activate() method in BlackBerry?
There is not that much info available.

Answer 1

It's difficult to answer this question because of the comment below Peter's answer. Activity#onResume() in Android is not normally used simply "to refresh ... UI data on the spot after making changes".
Android
onResume() is called by the Android OS when a user comes (back) to an Activity; this usually happens after leaving it ... either because another Activity was displayed in front of it, or because the user left your application and came back to it (going home and back, to the phone and back, etc.)
BlackBerry
In BlackBerry, Application#activate() is called when the user returns to your app. This callback happens at the app level. An app in Android is made of many Activies (normally). onResume() gets called separately for each Activity in your app, as the user returns to that individual Activity.
Although not identical, a similar construct in BlackBerry is the Screen class. One app may have many Screens, as Android apps have many Activities. So, if you're looking for the most similar thing to onResume(), I would try, as Peter suggested:
Screen#onExposed()
Screen#onUiEngineAttached(boolean)
To get closest to onResume(), you probably need both of those methods, because Screen#onExposed() does not get called the first time your Screen is shown (while Activity#onResume() does). You would override these methods in your own classes that extend Screen (or MainScreen, etc.)
If your problem is just determining when to refresh your UI, you'll need to explain more about what kind of UI objects (Fields) you're using, and when you get new data to display.
Update:
Here is some sample code for how you might build your main Screen class, to try to mimic Android's onResume() callback:
public final class MyScreen extends MainScreen {
public MyScreen() {
setTitle("MyTitle");
}
protected void onExposed() {
super.onExposed();
onResume();
}
protected void onUiEngineAttached(boolean attached) {
super.onUiEngineAttached(attached);
if (attached) {
onResume();
}
}
private void onResume() {
// TODO: put your Android-like processing here
System.out.println("onResume()");
}
}

Answer 2

There is nothing really to know about activate(). If you look at the documentation
http://www.blackberry.com/developers/docs/7.1.0api/net/rim/device/api/system/Application.html
it says:
"The system invokes this method when it brings this application to the foreground."
So if your application has been pushed to the background (for example, by a phone call), and then the user clicks on your icon to look at your application again, then activate() will be called. By contrast, deactivate() will be called when the system pushes your application to the background (for example, when a phone call is received).
Note that activate() is also called when the application is first started.
The question really is what do you do in onResume() that you need to replicate in the BlackBerry code. If you can tell us this, we might be able to suggest what is the best way to achieve the result you want.
Update
Given that you appear to be using onResume() to update a Ui, there is unfortunately, no one simple way of doing this for the entire application. The method you would use actually depends on what is being updated.
But be aware that most Fields are updated automatically when you change their contents. To give a simple example, if you have an EditField that contains data, and you use the
.setText("new data");
method, this will automatically repaint that Field on the screen for you.
I expect that you have a screen that you have populated from the database or data source, and in activate() you want to refresh this data. So you will have to go through each of the screen's Fields and use the associated set... method to update the contents.
This is slightly problematic, because activate is called for the Application, not the screen, and you might have multiple screens on the stack, and you really need to update all of them There are various methods available to do this, involving say, your screens registering themselves to be updated, or your activate() method searching the display stack for the screens there.
But possibly a simple approach is to use each screen's 'onExposed()' method to automatically update the contents. This method is called anytime the screen is hidden and then shown, which is exactly what would happen after the application has been foregrounded. It also happens when the screen is hidden by another screen being pushed on top of it, or even a user pressing the menu key. So perhaps, if the update is time consuming (for example requires a database lookup), you might want not want to update every time onExposed() is invoked, but instead try to restrict the update frequency.
This 'onExposed()' approach does not get out of the requirement to update the contents of each Field separately, but it might make it easier to implement.
Further update
Note Nate's answer, Nate has experience of both Android and BB, so can better relate to your problem.
But if you know that the screen has been updated, so you have just processed a network request that relates t that screens content, then you should go through each of the Field individually, "set"ting the updated value at that time, don't worry about using onExposed(). One design approach that accommodates this is to separate the screen construction from the screen population, so you can call the 'population' from multiple places (note that you do need to be on the Event Thread when you update the Fields).
But in this circumstance, you might find it easier and faster to create a new Screen and push that and pop the old screen (which has the old values).