Super Apps are designed to take into account the BlackBerry® device models that they run on and the variable levels of connectivity. Super Apps are also designed to take into account different types of connections with different associated costs. Often, Wi-Fi® connections are cheap, and roaming cellular connections are expensive.

Your application can determine the type of network the device is connected to, discover and interpret signal levels, and check if a device is using a roaming cellular connection.

You can use RadioInfo.getSignalLevel() to get the signal level of the current connection. The following table can help you interpret the results.

Use the NETWORK_SERVICE_ROAMING flag to determine if a device is currently using a roaming cellular connection, as demonstrated in the following code sample.

int networkService = RadioInfo.getNetworkService();
if ( (networkService & RadioInfo.NETWORK_SERVICE_ROAMING) != 0)
{
   //BlackBerry device is using a roaming connection
}

Your can register a BlackBerry® device application so it is notified when power level change events take place on the device it is running on. If the battery power level is low, you can respond by turning off or modifying some features of your application to conserve power. When your application receives notification that the battery power level is good again, you can turn on those features again.

To process power level change events, your application must implement the net.rim.device.api.system.SystemListener interface.

import java.util.*;
import net.rim.device.api.system.*;
import net.rim.device.api.ui.*;
import net.rim.device.api.ui.component.*;

public class PowerChangeEvent
extends Application implements SystemListener
{
   public static PowerChangeEvent theApp;

   public static void main(String args[])
   {
      theApp = new PowerChangeEvent();
      theApp.enterEventDispatcher();
   }

   public PowerChangeEvent()
   {
      Application.getApplication().addSystemListener(this);
      System.out.println("PowerChangeEvent: PowerChangeEvent has started!");
   }

   public void powerOff()
   {
      System.out.println("PowerChangeEvent: The device is powering off.");
   }

   public void powerUp()
   {
      System.out.println("PowerChangeEvent: The device is powering up.");
   }

   //Invoked when the internal battery voltage falls below a critical level.
   public void batteryLow()
   {
      System.out.println("PowerChangeEvent: The battery is getting low!");
   }

   //Invoked when the internal battery voltage has returned to normal.
   public void batteryGood()
   {
      System.out.println("PowerChangeEvent: The battery level is now good!");
   }

   //Invoked when the internal battery state has changed.
   //Not used in this sample.
   public void batteryStatusChange(int status)
   {
   }
}

A BlackBerry® device user can use a BlackBerry device application to access GPS data and view information on the location, speed, and direction of the BlackBerry device. A BlackBerry device application can use a source for GPS data that provides data within specific accuracy parameters, at a specific cost, and uses a specific amount of battery power.

A BlackBerry device creates an object of the javax.microedition.location.Criteria class and invokes the methods of the class to specify the source of GPS data. For example, a BlackBerry device application invokes Criteria.setHorizontalAccuracy(2) and Criteria.setVerticallAccuracy(2) to specify that a source of GPS data must provide vertical and horizontal data values that is accurate within 2 meters of the actual values. A BlackBerry device application invokes Criteria.setCostAllowed(true) to use a source of GPS data that costs money to use. The BlackBerry device application can invoke Criteria.setPreferredPowerConsumption(POWER_USAGE_LOW) to use a source of GPS data that makes minimal use of the battery power on a BlackBerry device.

A BlackBerry device application sets the properties of the Criteria object to specify the mode the application uses to retrieve GPS data. The cell site mode allows a BlackBerry device application to retrieve GPS data from a cell site tower. This mode is faster but less accurate than other modes. The assisted mode allows a BlackBerry device application to retrieve GPS data from a satellite. This mode is faster than the autonomous mode and more accurate than the cell site mode. The autonomous mode allows a BlackBerry device application to retrieve GPS data from the BlackBerry device. This mode is slower but more accurate than other modes.

After creating and setting the properties of the Criteria object, a BlackBerry device application invokes javax.microedition.location.LocationProvider.getInstance(Criteria) using the Criteria object as a parameter to retrieve a LocationProvider object. A BlackBerry device application can invoke LocationProvider.getLocation() to retrieve an object of the javax.microedition.location.Location class to access data for a location.

Invoking the Location.getSpeed() and Location.getCourse() methods retrieves the speed and the direction of the BlackBerry device. Invoking the Location.getQualifiedCoordinates() method retrieves a javax.microedition.location.QualifiedCoordinates object that can provide the latitudinal and longitudinal coordinates of the BlackBerry device.

A BlackBerry device application can listen for updates from a source for GPS data to provide a BlackBerry device user with current GPS information. The BlackBerry device application must implement the javax.microedition.location.LocationListener interface and invoke the LocationProvider.setLocationListener(LocationListener int, int, int) method to register the LocationListener with a LocationProvider.You can invoke LocationProvider.setLocationListener(LocationListener int, int, int) and use an integer value as the interval argument to specify how often, in seconds, the BlackBerry device application checks for new GPS data.

1. Import the required classes.

   import javax.microedition.location.*;

2. Create a class and a constructor.

   public class handleGPS
   {
      public handleGPS()
      {
      }
   }

3. Declare static fields in the class.

   static GPSThread gpsThread;
   static double latitude;
   static double longitude;

4. In the constructor, create and start a local thread.

   gpsThread = new GPSThread();
   gpsThread.start();

5. In the class, create a private class that extends Thread, and create a run() method.

   private class GPSThread extends Thread
   {
      public void run()
      {
      }
   }

6. In the run() method, create an instance of the Criteria class. Invoke setCostAllowed(false) to specify that the autonomous mode.

   Criteria myCriteria = new Criteria();
   myCriteria.setCostAllowed(false);

7. In the run() method, create a try/catch block. In the block create a LocationProvider object by getting an instance of the Criteria object. Create another try/catch block to create a Location object to request the current location of the BlackBerry® device and specify the timeout period in seconds. When the getLocation() method returns, request the latitude and longitude coordinates.

   try
   {
       LocationProvider myLocationProvider =
           LocationProvider.getInstance(myCriteria);
   
       try
       {
           Location myLocation = myLocationProvider.getLocation(300);
           latitude  = myLocation.getQualifiedCoordinates().getLatitude();
           longitude = myLocation.getQualifiedCoordinates().getLongitude();
       }
       catch ( InterruptedException iex )
       {
           return;
       }
       catch ( LocationException lex )
       {
           return;
       }
   }
   catch ( LocationException lex )
   {
       return;
   }
   return;

You can add a pop-up menu and a submenu to your application by using the classes provided in the net.rim.device.api.ui.menu package.

Menu	Description
Pop-up menu	A pop-up menu, similar to a context menu, contains a list of the most common actions that BlackBerry® device users can perform within the current context. An item in the pop-up menu can include the text, an application icon, and a command. A pop-up menu replaces a context menu, or a short menu, that was available in previous versions of the BlackBerry® Java® SDK. The BlackBerry® Device Software automatically converts an existing context menu into a pop-up menu.
Submenu	A submenu is a group of related menu items. A submenu appears as a subset of a menu item in the full menu. When you include items in a submenu, users can find frequently-used items or important items more easily in the full menu.

You can create a pop-up menu by using classes that are available in the net.rim.device.api.ui.menu package, and you can define the functionality of the pop-up menu items by using the Command Framework API.

A pop-up menu consists of a context menu provider, a command item provider, and command items.

If you use a legacy context menu, BlackBerry® Device Software 6.0 converts the context menu items to command items and provides them to the command item provider. For more information, see Support for legacy context menus.

1. Import the required classes and interfaces.

   import net.rim.device.api.command.*;
   import net.rim.device.api.system.*;
   import net.rim.device.api.ui.*;
   import net.rim.device.api.ui.component.*;
   import net.rim.device.api.ui.container.*;
   import net.rim.device.api.ui.menu.*;
   import net.rim.device.api.ui.image.*;
   import net.rim.device.api.util.*;
   import java.util.*;

2. Create the application framework by extending the UiApplication class. In main(), create an instance of the new class and invoke enterEventDispatcher() to enable the application to receive events. In the application constructor, invoke pushScreen() to display the custom screen for the application. The MyPopUpMenuScreen class, which is described in step 3, represents the custom screen.

   public class MyPopUpMenuApp extends UiApplication 
   {
       public static void main(String[] args)
       {
           Mypop-upMenuApp theApp = new Mypop-upMenuApp();
           theApp.enterEventDispatcher();
       }
       
       public Mypop-upMenuApp()
       {
          	pushScreen(new Mypop-upMenuScreen());
       } 
   }

3. Create the custom screen for the application by extending the MainScreen class. In the screen constructor, invoke setTitle() to specify the title for the screen.

   class MyPopUpMenuScreen extends MainScreen
   {
       EmailAddressEditField emailAddress;
       public Mypop-upMenuScreen()
       {       
           setTitle("Pop-Up Menu Demo");
       }
   }

4. In the screen constructor, specify a context menu provider. Pass a DefaultContextMenuProvider object to Screen.setContextMenuProvider() to enable your screen to display a pop-up menu.

   setContextMenuProvider(new DefaultContextMenuProvider());

5. In the screen constructor, create UI components that can invoke the pop-up menu. In the following code sample, the label uses the Field.FOCUSABLE property to allow users to highlight the field.

   LabelField labelField = new LabelField("Click to invoke pop-up menu", Field.FOCUSABLE);
   emailAddress = new EmailAddressEditField("Email address: ", "name@blackberry.com", 40);

6. In the screen constructor, configure the UI components as command item providers. The DefaultContextMenuProvider object looks for fields that are configured as command item providers, and uses them to create and display a pop-up menu. For each component, invoke Field.setCommandItemProvider() to configure the field as a command item provider. The ItemProvider class is described in step 7.

   ItemProvider itemProvider = new ItemProvider();
                          
   labelField.setCommandItemProvider(itemProvider);
   emailAddress.setCommandItemProvider(itemProvider);

7. In the custom screen, implement the CommandItemProvider interface. In getContext(), return the field that is configured as a command item provider. In getItems(), create a Vector object to add the pop-up menu items to.

   class ItemProvider implements CommandItemProvider 
   {
       public Object getContext(Field field)
       {
           return field;
       }
       public Vector getItems(Field field)
       {
       }
   }

8. In getItems(), provide the pop-up menu items by creating instances of the CommandItem class. For each command item, specify the pop-up menu text, icon, and command. In the following code sample, an if-then-else statement is used to check which component invoked the pop-up menu before creating the CommandItem. The command is a proxy to an instance of a class that extends the abstract CommandHandler class, which is described in step 9. Invoke Vector.addElement() to add the pop-up menu items to the Vector. Return the Vector.

   CommandItem defaultCmd;
   
   Image myIcon = ImageFactory.createImage(Bitmap.getBitmapResource("my_logo.png"));
   
   if(field.equals(emailAddress)){          
       defaultCmd = new CommandItem(new StringProvider("Email Address"), myIcon, new Command(new DialogCommandHandler()));
   }
   else {
       defaultCmd = new CommandItem(new StringProvider("Label Field"), myIcon, new Command(new DialogCommandHandler()));
   }
   
   items.addElement(defaultCmd);
   
   return items;

9. In the custom screen, create a command handler by creating a class that extends the abstract CommandHandler class. In execute(), define the functionality that you want to associate with the pop-up menu items. This command handler could be used by any UI component on your screen (for example, full menu items, buttons, and so on). Because canExecute() is not implemented, this command is always executable. In the following code sample, a dialog box appears when the user clicks a pop-up menu item.

   class DialogCommandHandler extends CommandHandler
   {
       public void execute(ReadOnlyCommandMetadata metadata, Object context)
       {
           Dialog.alert("Executing command for " + context.toString());
       }           
   }