22 Testing and Debugging MAF Applications

22.2.1 How to Perform Accessibility Testing on iOS-Powered Devices

You should use a combination of the following methods to test the accessibility of your MAF application developed for iOS-powered devices:

• Testing with the Accessibility Inspector on an iOS-powered device simulator.

  For detailed information, see the "Testing the Accessibility of Your iPhone Application" section in the Accessibility Programming Guide for iOS available through the iOS Developer Library.

• Testing with the VoiceOver on an iOS-powered device.

  For more information, see the "Using VoiceOver to Test Your Application" section in the Accessibility Programming Guide for iOS available through the iOS Developer Library.

22.3.1 What You May Need to Know About the Debugging Configuration

When the application is created, MAF automatically configures the project properties for remote debugging. This includes creating a model debugging configuration. If this were a manual step, you would perform it as follows:

1. From the JDeveloper's main menu, click Application > Project Properties to open the Project Properties dialog.

2. In the Project Properties dialog, select the Run/Debug node.

3. Using the Run Configurations pane of the Run/Debug dialog, create a new configuration, or click Edit to modify an existing one.

4. In the Edit Run Configuration > Launch Settings dialog, select Remote Debugging.

5. Expand the Tools Settings node of the Edit Run Configuration dialog, then expand Debugger, and then select Remote.

6. In the Edit Run Configuration > Remote dialog that Figure 22-1 shows, perform the following configurations:

   • Set the protocol to Attach to JPDA.

   • Set the host to one of the following:

     • For simulator or emulator debugging, set to localhost.

     • For the device debugging, ensure that your development computer can access that device over the network (you may use the ping command to test network access), and then enter the device's IP address.

   • Set the port to the appropriate port number.

   • Set the time-out to 2.

   Figure 22-1 Configuring Remote Debugging

   
   

In addition, MAF specifies the following debugging parameter in the cvm.properties file:

java.debug.port=8000

This port number matches the one set in JDeveloper.

22.3.2 How to Debug on iOS Platform

To debug a MAF application on the iOS platform using JDeveloper, follow the generic debugging procedure described in Section 22.3, "Debugging MAF Applications."

For information on how to configure an iOS-powered device or simulator and how to deploy a MAF application for debugging, see the following:

• Section 19.4.1, "How to Deploy an iOS Application to an iOS Simulator"

• Section 19.4.2, "How to Deploy an Application to an iOS-Powered Device"

• Section 19.4.4.2, "Registering an Apple Device for Testing and Debugging"

22.3.3 How to Debug on Android Platform

To debug a MAF application on the Android platform using JDeveloper, follow the generic debugging procedure described in Section 22.3, "Debugging MAF Applications."

For information on how to configure an Android-powered device or emulator and how to deploy a MAF application for debugging, see Section 19.3.1, "How to Deploy an Android Application to an Android Emulator."

To allow debugging of a MAF application running on an Android-powered device or its emulator, you enable the Network device access option in the maf-application.xml file, as Figure 22-2 shows.

Figure 22-2 Enabling Android Debugging

When you debug Java code, either on an Android-powered device connected through USB or on an Android-powered device emulator, you need to forward the TCP port by executing the following command on a terminal:

• For the device debugging:

  adb -d forward tcp:8000 tcp:8000

• For the emulator debugging:

  adb -e forward tcp:8000 tcp:8000

Upon execution, the debugging setting in the cvm.properties file (see Section 22.3.5, "How to Enable Debugging of Java Code and JavaScript") should be defined as follows:

java.debug.enabled=true

22.3.4 How to Debug the MAF AMX Content

If your MAF application includes the MAF AMX content, after you configure the device or emulator, you can set breakpoints, view the contents of variables, and inspect the method call stack just as you would when debugging other types of applications in JDeveloper.

22.3.5 How to Enable Debugging of Java Code and JavaScript

A cvm.properties file allows you to specify startup parameters for the JVM and web views of MAF to enable debugging of the Java code and JavaScript. The cvm.properties file is automatically created and placed in the Descriptors/META-INF directory under the Application Resources (see Section 22.4, "Using and Configuring Logging"), which corresponds to the <application_name>/src/META-INF location in your application file system.

You can use the following debugging properties in the cvm.properties file:

• java.debug.enabled: Enables or disables Java debugging for MAF. Valid values are true and false.

  Caution:

  When java.debug.enabled is set to true, the JVM waits for a debugger to establish a connection to it. Failure of the debugger to connect will result in the failure of the MAF AMX application feature to load.

• java.debug.port: Specifies the port to be used during debugging. The valid value is an integer.

• javascript.debug.enabled: Enables or disables JavaScript debugging when the application is running in the device simulator. Valid values are true and false.

• javascript.debug.feature: Specifies the application feature that is to trigger the activation of JavaScript debugging in MAF. The format of the value is featureId:port . The port must be specified (it is initially set to a placeholder value).

The contents of the cvm.properties file may be similar to the following:

java.debug.enabled=true
java.debug.port=8000

javascript.debug.enabled=true
javascript.debug.feature=products:8888

After the cvm.properties file has been configured to debug JavaScript, you can navigate to the following URL to see a listing of all the loaded pages that can be debugged in MAF:

http://localhost:9999

For information on how to use JDeveloper to debug the Java code, see Section 22.3, "Debugging MAF Applications."

22.3.5.1 What You May Need to Know About Debugging of JavaScript Using an iOS-Powered Device Simulator on iOS 6 Platform

If you are working with the iOS 6 platform, you can use the Safari 6 browser to debug JavaScript. To do so, open the Safari preferences, select Advanced, and then enable the Develop menu in the browser by selecting Show Develop menu in menu bar, as shown in Figure 22-3.

Figure 22-3 Enabling Safari Browser Options

When the Develop menu is enabled, select either iPhone Simulator or iPad Simulator, as Figure 22-4 and Figure 22-5 show, and then select a UIWebView that you are planning to debug. Whether the Develop menu displays an iPhone Simulator or iPad Simulator option depends on which device simulator is launched.

Figure 22-4 Using Develop Menu on Safari Browser for Debugging on iPhone Simulator

Figure 22-5 Using Develop Menu on Safari Browser for Debugging on iPad Simulator

22.3.6 How to Configure the Debug Mode

You use the application's deployment profile to specify either the release or debug execution mode for your MAF application. Only the debug mode enables you to interactively debug Java and JavaScript code. The debug mode allows for inclusion of special debugging libraries and symbols at compile time.

Figure 22-6 shows how to set the debug mode option on Android.

Figure 22-6 Setting Debug Mode for Android

Figure 22-7 shows how to set the debug mode option on iOS.

Figure 22-7 Setting Debug Mode for iOS

When you deploy your application in debug mode, just before the end of the deployment process the following log message is printed out in JDeveloper:

This MAF app was deployed in Debug mode and should not be used for performance evaluation purposes. Set the deployment profile Build Mode option to Release for performance testing.

Figure 22-8 Deployment Log Message

For more information, see the following:

• Section 19.2.3, "How to Create an Android Deployment Profile"

• Section 19.2.4.1, "Defining the iOS Build Options"

• Section 19.4.4.1, "Creating iOS Development Certificates"

22.4.1 How to Configure Logging Using the Properties File

Example 22-1 shows the logging.properties file that you use to configure logging.

# default - all loggers to use the ConsoleHandler
.handlers=com.sun.util.logging.ConsoleHandler
# default - all loggers to use the SimpleFormatter
.formatter=com.sun.util.logging.SimpleFormatter

oracle.adfmf.util.logging.ConsoleHandler.formatter=
             oracle.adfmf.util.logging.PatternFormatter
oracle.adfmf.util.logging.PatternFormatter.pattern=
             [%LEVEL%-%LOGGER%-%CLASS%-%METHOD%]%MESSAGE%

#configure the framework logger to only use the adfmf ConsoleHandler
oracle.adfmf.framework.useParentHandlers=false
oracle.adfmf.framework.handlers=oracle.adfmf.util.logging.ConsoleHandler
oracle.adfmf.framework.level=SEVERE

#configure the application logger to only use the adfmf ConsoleHandler
oracle.adfmf.application.useParentHandlers=false
oracle.adfmf.application.handlers=oracle.adfmf.util.logging.ConsoleHandler
oracle.adfmf.application.level=SEVERE

The oracle.adfmf.util.logging.ConsoleHandler plays the role of the receiver of the custom formatter.

The oracle.adfmf.util.logging.PatternFormatter allows the following advanced formatting tokens that enable log messages to be printed:

• %LEVEL%—the logging level.

• %LOGGER%—the name of the logger to which the output is being written.

• %CLASS%—the class that is being logged.

• %METHOD%—the method that is being logged.

• %TIME%—the time the logging message was sent.

• %MESSAGE%—the actual message.

The following logging levels are available:

• SEVERE: this is a message level indicating a serious failure.

• WARNING: this is a message level indicating a potential problem.

• INFO: this is a message level for informational messages.

• FINE: this is a message level providing tracing information.

• FINER: this level indicates a fairly detailed tracing message.

• FINEST: this level indicates a highly detailed tracing message.

The logger defined in the logging.properties file matches the logger obtained from the oracle.adfmf.util.Utility class (see Section 22.4, "Using and Configuring Logging"). The logging levels also match. If you decide to use the logging level that is more fine-grained than INFO, you have to change the ConsoleHandler's logging level to the same level, as Example 22-2 shows.

oracle.adfmf.util.logging.ConsoleHandler.formatter=
             oracle.adfmf.util.logging.PatternFormatter
oracle.adfmf.util.logging.ConsoleHandler.level=FINEST
oracle.adfmf.util.logging.PatternFormatter.pattern=
             [%LEVEL%-%LOGGER%-%CLASS%-%METHOD%]%MESSAGE%

22.4.2 How to Use JavaScript Logging

JavaScript writes the output to the console.log or.error/.warn/.info. This output is redirected into the file through the System.out utility.

You customize the log output by supplying a message. The following JavaScript code produces "Message from JavaScript" output:

<script type="text/javascript" charset="utf-8">
   function test_function() { console.log("Message from JavaScript"); }
</script>

To make use of the properties defined in the logging file, you need to use the adf.mf.log package and the Application logger that it provides.

The following logging levels are available:

• adf.mf.log.level.SEVERE

• adf.mf.log.level.WARNING

• adf.mf.log.level.INFO

• adf.mf.log.level.CONFIG

• adf.mf.log.level.FINE

• adf.mf.log.level.FINER

• adf.mf.log.level.FINEST

To trigger logging, use the adf.mf.log.Application logger's logp method and specify the following through the method's parameters:

• the logging level

• the current class name as a String

• the current method as a String

• the message string as a String

Example 22-3 shows how to use the logp method in a MAF application.

adf.mf.log.Application.logp(adf.mf.log.level.WARNING,
                            "myClass",
                            "myMethod",
                            "My Message");

Upon execution of the logp method, the following output is produced:

[WARNING - oracle.adfmf.application - myClass - myMethod] My Message

22.4.3 How to Use Embedded Logging

Embedded logging uses the com.sun.util.logging.Logger, as illustrated in Example 22-4. Note that the EmbeddedClass represents a Java class defined in the project.

import com.sun.util.logging.Level;
import com.sun.util.logging.Logger;
import oracle.adfmf.util.logging.*;
...
   Utility.ApplicationLogger.logp(Level.WARNING, 
                                  EmbeddedClass.class.getName(),
                                  "onTestMessage",
                                  "embedded warning message 1");
   Logger.getLogger(Utility.APP_LOGNAME).logp(Level.WARNING,
                    this.getClass().getName(),
                    "onTestMessage",
                    "embedded warning message 2");
   Logger.getLogger("oracle.adfmf.application").logp(Level.WARNING,
                                                this.getClass().getName(),
                                                "onTestMessage",
                                                "embedded warning message 3");

The preceding code produces the following output:

[WARNING - oracle.adfmf.application - EmbeddedClass - onTestMessage] embedded warning message 1
[WARNING - oracle.adfmf.application - EmbeddedClass - onTestMessage] embedded warning message 2
[WARNING - oracle.adfmf.application - EmbeddedClass - onTestMessage] embedded warning message 3

22.4.4 How to Use Xcode for Debugging and Logging on iOS Platform

Even though it is not recommended to manipulate your MAF projects with Xcode because you can lose some or all of your changes during the next deployment with JDeveloper, you may choose to do so in exceptional circumstances.

Before you begin:

Deploy the application to the iOS simulator from JDeveloper.

To open the generated project directly in Xcode:

1. Navigate to the workspace_directory\deploy\deployment profile name\temporary_xcode_project\.

2. Open the Xcode project called Oracle_ADFmc_Container_Template.xcodeproj.

If your development computer is running on Mac OS 10.8.n and you are debugging your MAF application using Xcode, you cannot see the Java output in the IDE (on either JDeveloper console or Xcode console). Instead, the output is redirected to a file (see Section 22.4, "Using and Configuring Logging"). By adding the following argument to your application's schema, you can disable this behavior and enable access to the Java, JavaScript, and Objective-C log output in Xcode in real time when debugging on either an iOS-powered device or its simulator:

-consoleRedirect=FALSE

22.4.5 How to Access the Application Log

Using the following APIs, you can access the application log information:

• oracle.adfmf.framework.api.PerfMon

• oracle.adfmf.framework.api.LogEntry

• oracle.adfmf.util.HOTS

For more information, see Oracle Fusion Middleware Java API Reference for Oracle Mobile Application Framework.