Below you can see the List of supported Queue-Methods:

SBQueue Methods

#import "SBQueue.h"

SBQueue *queue = [[SBQueue alloc] initWithQueueSize:10];
[queue addObject:[[NSString alloc] initWithString:@"Hello SBQueue"]];

If you have some improvements, feel free to drop a line below.

Technorati Tags: apple, iphone development, mac, nsqueue, objective-c, sbqueue, unit tests

• Introduction
• Create the Application
• Create the Selenium Test
• Download
• Conclusion

Introduction

For a Customer Project i had to write a SOAP Web Service (for Interaction with an iPhone App) and for Test Driven Development i needed an easy way to create some Tests. First, i wrote a JUnit Test. Ok it worked, but the problem is that it is not usable with Continuous Integration, because it can only be tested against a running Grails-App. So i decided to use the good old Selenium-Framework.

The Selenium-Framework starts the Grails-App (with the Server) and runs the Tests against it! Now i want to show you the (simple!) solution.

I am using Grails 1.3.7 .

Create the Application

First, you have to add the Plugins “cxf” and “selenium-rc” to your project (in this example the project is named as “GrailsWebServiceWithSeleniumTest“. Here is my configuration-file:

application.properties

app.grails.version=1.3.7
app.name=GrailsWebServiceWithSeleniumTest
app.servlet.version=2.4
app.version=0.1
plugins.cxf=0.7.0
plugins.hibernate=1.3.7
plugins.selenium-rc=1.0.2
plugins.tomcat=1.3.7

Add this line to your “BuildConfig.groovy” to resolve the correct Maven dependency for the “Apache Httpclient commons“.

BuildConfig.groovy

runtime("commons-httpclient:commons-httpclient:3.1")

Create the Service “eu.jdevelop.blog.MyTestService” and insert this code:

MyTestService.groovy

package eu.jdevelop.blog

import javax.jws.WebParam
import javax.jws.WebResult
import javax.jws.WebService
import javax.jws.WebMethod

/**
 * Creates a Web Service with JAX-WS Annotations
 * URL: http://localhost:8080/GrailsWebServiceWithSeleniumTest/services/myTest?wsdl
 *
 * @author Siegfried Bolz
 */
@WebService(name = "MyTestWebService", targetNamespace = "eu.jdevelop.blog", serviceName = "MyTestWebServiceName")
class MyTestService {

  // Using Plugin cxf
  static expose = ['cxfjax']

  /**
   * Web Service Operation
   *
   * @param firstName String
   * @param lastName String
   * @return message String
   */
  @WebResult(name = "loginResult")
  @WebMethod(operationName = "login")
  String login(@WebParam(name = "firstname") String firstName, @WebParam(name = "lastname") String lastName) {
    return "Hello " + firstName + " " + lastName
  }
}

This is the Web Service, using JAX-WS-Annotations for the Contract Last approach. As you can see, i declare everything with the Annotations.

Now start the Grails Application, you can browse to it at:

http://localhost:8080/GrailsWebServiceWithSeleniumTest/services/myTest?wsdl

Created WSDL

You can use Tools like “soapui” to create sample Requests for testing.

Create the Selenium Test

The next step is to create the Selenium Test. In Grails there is now the new Directory “/test/selenium“. Create the file “eu.jdevelop.blog.MyTestServiceSeleniumTests.groovy” and insert this:

MyTestServiceSeleniumTests.groovy

package eu.jdevelop.blog

import grails.plugins.selenium.SeleniumAware
import org.apache.commons.httpclient.HttpClient
import org.apache.commons.httpclient.methods.PostMethod
import org.apache.commons.httpclient.methods.StringRequestEntity

/**
 * Selenium-Test for the Web Service, uses Selenium for starting the Grails Server.
 *
 * @author Siegfried Bolz
 */
@Mixin(SeleniumAware)
class MyTestServiceSeleniumTests extends GroovyTestCase {

  void testLoginMethod() {
    selenium.open "http://localhost:8080/GrailsWebServiceWithSeleniumTest/services/myTest?wsdl"

    def url = "http://localhost:8080/GrailsWebServiceWithSeleniumTest/services/myTest?wsdl"

    def payload = """
            <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:eu="eu.jdevelop.blog">
              <soapenv:Header/>
                <soapenv:Body>
                  <eu:login>
                    <firstname>Siegfried</firstname>
                    <lastname>Bolz</lastname>
                  </eu:login>
                </soapenv:Body>
            </soapenv:Envelope>"""

    def method = new PostMethod(url)
    def client = new HttpClient()

    payload = payload.trim()
    method.addRequestHeader("Content-Type", "text/xml")
    method.addRequestHeader("Accept", "text/xml,application/xml;q=0.9")
    method.setRequestEntity(new StringRequestEntity(payload))
    def statusCode = client.executeMethod(method)
    println "STATUS CODE : ${statusCode}"

    assertEquals "Status Code 200 expected", 200, statusCode

    def resultsString = method.getResponseBodyAsString()
    println resultsString

    assertTrue "Result did not contain the expected result message", resultsString.contains("<loginResult>Hello Siegfried Bolz</loginResult>")

    method.releaseConnection()
  }

}

To start the test, execute this command:

test-app :selenium eu.jdevelop.blog.MyTestServiceSeleniumTests.testLoginMethod -echoOut

As VM parameters i recommend:

-Xmx1024m -Xms1024m -XX:NewSize=512m -XX:MaxNewSize=512m -XX:MaxPermSize=256m

Selenium Test in IDEA

Download

A working example for Grails 1.3.7 and IntelliJ IDEA 10 is available here (click)

Conclusion

As you can see, it is very simple to create a Web Service with a Selenium Test. If you have any comments, drop a line below.

Technorati Tags: annotations, contract last, create, cxf, Grails, gui test, intellij idea, jax-ws, selenium, soap, test, testing, tutorial, web service

• Introduction
• How to use it
• Download
• Conclusion

Introduction

Validation of GUI-Components on an iPhone/iPad (iDevice) is not a simple task. The most common (stupid) way is to use a specific validation-method for every field. This is much boilerplate code which i want to avoid. So i have written a simple validation framework only for the UITextField and UITextView -fields. Other components are following soon with a more advanced framework.

So, what can my simple validation framework do? First, take a look at these pictures (click on each for fullsize):

Some empty input fields

Now i insert some values and hit the “Validate”-Button.

Validation errors

You see a Popup-Window with a summary of the found validation errors. After click on ‘ok’ you see all fields with errors marked red.

Fields with validation errors are marked red

How to use it

As the title of this posting said, it is very simple. First, drop the framework-class-files (header and implementation) into your project. These are:

• ValidationModel
• Validator
• ValidatorTextFieldProtocol
• MyColors
• EnhancedTextField
• EnhancedTextView

Then connect all of your UITextField and UITextView-fields with Outlets. After that you have to create for each of these fields a ValidationModel and store it into a NSMutableArray. You have to pass some parameters for the Validation. These are ‘Minimum char length‘, ‘Maximum char length‘ and ‘Empty field allowed‘. Additionally you can specify a special error message, shown when the field is empty, to tell the User why and what he has to enter.

- (void)viewDidLoad
{
  [super viewDidLoad];
  [self showTextView:self.view :comments];

  // Save all fields which you want to validate inside the 'propertiesList'
  propertiesList = [[NSMutableArray alloc] init];

  [propertiesList addObject:[[ValidationModel alloc] initWithValues:name :NO :@"You have to insert a very important value!" :2 :5]];
  [propertiesList addObject:[[ValidationModel alloc] initWithValues:street :YES :nil :0 :10]];
  [propertiesList addObject:[[ValidationModel alloc] initWithValues:comments :NO :nil :1 :5]];
}

Now connect the Button, which activates the validation (or saves the data), with an Action. In this method you will instantiate the Validation-Engine and call the Validation-Method with the (previously created) ValidationModels-List.

/**
 * This method is called when the User hits the 'Validate'-Button. It now
 * validates the TextFields/TextViews, previously assigned in the 'viewDidLoad'.
 */
- (IBAction)validateAction:(id)sender {
  // Initalize the Validator-Engine with standard error messages
  Validator *val = [[Validator alloc] initWithErrorMessages:@"You have to insert %@ chars as a minimum!" :@"You have insert to much chars. Maximum are %@ chars" :@"Empty field is not allowed!"];

  // Validate now! The return-value contains the error-messages with the corresponding fieldname
  NSMutableDictionary *resultErrorMap = [val validatePropertiesList:propertiesList];
  NSLog(@"*** Received Error messages: %i", [resultErrorMap count]);

}

That’s it! Your Validation-Framework is armed and ready for action! You can parse the ‘resultErrorMap‘ and show a splash screen with some infos about the errors (like in the first Screenshot above).

Download

A working example for iOS 4.3 is available here (click)

Conclusion

This framework is very simple and easy to use. You can only validate the most common input-fields, but you have the ability to include other UITextField/UITextView-Implementations by using the ‘ValidatorTextFieldProtocol‘ (polymorphic stuff). I hope you can use it, drop a line in the comments what you think about it.

I am currently working on an advanced framework which uses plugins to customize the validation for the other GUI-Components of the UIKit-Framework. So stay tuned!

Technorati Tags: framework, gui, ipad, iPhone, objective-c, uitextfield, uitextview, validation

ReadIDevice-App

// Stores the complete Text Output
NSMutableString *data = [[NSMutableString alloc] init];

// Reading Legal Apple Data
[data appendString:[NSString stringWithFormat: @"%@: %@nn", @"phoneUniqueIdentifier", [[UIDevice currentDevice] uniqueIdentifier]]];
[data appendString:[NSString stringWithFormat: @"%@: %@nn", @"name", [[UIDevice currentDevice] name]]];
[data appendString:[NSString stringWithFormat: @"%@: %@nn", @"systemName", [[UIDevice currentDevice] systemName]]];
[data appendString:[NSString stringWithFormat: @"%@: %@nn", @"systemVersion", [[UIDevice currentDevice] systemVersion]]];
[data appendString:[NSString stringWithFormat: @"%@: %@nn", @"model", [[UIDevice currentDevice] model]]];
[data appendString:[NSString stringWithFormat: @"%@: %@nn", @"localizedModel", [[UIDevice currentDevice] localizedModel]]];

To access the IMEI and Serial Number you have to use the (semi)public IOKit framework. Erica Sadun has managed this and released the overwritten IOKit-Extension. I have included these files in my App and used it this way:

#import "UIDevice-IOKitExtensions.h"

// Reading not by the Appstore supported Data
[data appendString:[NSString stringWithFormat: @"%@: %@nn", @"IMEI", [[UIDevice currentDevice] imei]]];
[data appendString:[NSString stringWithFormat: @"%@: %@nn", @"SerialNr", [[UIDevice currentDevice] serialnumber]]];

Be aware that you cannot submit an App with this IOKit-Extension into the Appstore!

Sadly, i found no solution for reading the Phone Number. In previous versions it was possible, but nevermore in iOS 4.3 . If someone has a solution, please drop a line in the comments.

Technorati Tags: appstore, imei, iokit-extension, ios 4.3, iPhone, objective-c, phone number, serial number

• Introduction
• A simple Example
• Launch the Application
• Conclusion

Introduction

A very annoying point in GWT is to write the (same) code to create Widgets and set the Properties. Most lines are filled with these boilerplate code. GWT 2.0 has a solution for this, it is called Generators. Generators are classes that are invoked by the GWT compiler to generate a Java implementation of a class during compilation. Instead of writing:

TextBox myTextBox = new TextBox();
myTextBox.setText("Hello World TextBox");
myTextBox.setName("blablubb");
myTextBox.setStyleName("ihatethis");
...

You can write this:

@FormField(styleName = "GWTstyleTextBox", parentAccessor = "verticalPanel", defaultText= "Hello World TextBox")
TextBox nameField;

What has happened? The boilerplate code was replaced by an Annotation. First the Generator translates the Annotation into a Java class and after that the compiler creates the corresponding JavaScript-Code (very crazy i know). You can use Annotations for nearly everything, but this blog shows you how to create TextBox and Label -fields.

A simple Example

First, take a look at MyPanel.java, where you can see the @FormField-Annotation in action, which generates code for a TextBox (nameField) and a Label (labelField). This is only working when the deferred binding mechanism GWT.create() is encountered while compiling.

MyPanel.java

package eu.jdevelop.gwt.anno.client;

import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.TextBox;
import com.google.gwt.user.client.ui.VerticalPanel;
import eu.jdevelop.gwt.anno.client.ui.forms.FormBinder;
import eu.jdevelop.gwt.anno.client.ui.forms.FormField;

/**
 * Component which contains an annotated TextField and LabelField
 *
 * @author Siegfried Bolz
 * @since 09.01.2010
 */
public class MyPanel {

	// Create this in every annotated class to support Field-Annotations
	interface InternalFormBinder extends FormBinder<MyPanel> {}
	private static final InternalFormBinder formBinder = GWT.create(InternalFormBinder.class);

	// Parent (Store) for the annotated Fields
	final VerticalPanel verticalPanel = new VerticalPanel();

	// Create a LabelField
	@FormField(styleName = "GWTstyleLabel", parentAccessor = "verticalPanel", defaultText= "Hello World Label")
	Label labelField;

	// Create a TextField
	@FormField(styleName = "GWTstyleTextBox", parentAccessor = "verticalPanel", defaultText= "Hello World TextBox")
	TextBox nameField;

	public MyPanel() {
		// Bind this instance to the FormBinder
		formBinder.bind(this);
	}

	public VerticalPanel getPanel() {
		return verticalPanel;
	}
}

The FormField-Annotation has only 3 parameters, which are set on every Field. If you want specific parameters you can create more Annotations or enhance this one with an intelligent system to activate them.

FormField.java

package eu.jdevelop.gwt.anno.client.ui.forms;

import java.lang.annotation.*;

/**
 * Annotation for all Field-Types
 *
 * @author Siegfried Bolz
 * @since 09.01.2010
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface FormField {
  String styleName() default "";
  String parentAccessor();
  String defaultText() default "";
}

The FormBinder-Interface is used for the deferred binding operation, the parameter can be accessed in the FormBinderGenerator-class.

FormBinder.java

package eu.jdevelop.gwt.anno.client.ui.forms;

import eu.jdevelop.gwt.anno.client.MyPanel;

/**
 * Simple Interface for binding operations
 *
 * @author Siegfried Bolz
 * @since 09.01.2010
 */
public interface FormBinder<T> {

  // Make "bind" generic to support more components
  void bind(MyPanel component);
}

The Generators are creating the Java-files. I have splitted this operation in three main and two sub files. BaseGenerator is used to create an empty File with imports, FormBinderGenerator adds some default actions like Field instantiation, setStyleName.. and implementations of FieldGenerator adds Field specific operations.

BaseGenerator.java

package eu.jdevelop.gwt.anno.ui;

import com.google.gwt.core.ext.Generator;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.uibinder.rebind.IndentedWriter;

import java.io.PrintWriter;

/**
 * Create the Implementation-Class and add a basic header data for ALL
 * generated Annotations.
 *
 * @author Siegfried Bolz
 * @since 09.01.2010
 */
public abstract class BaseGenerator extends Generator {
  protected static final String IMPORT = "import %1$s;";
  protected static final String PACKAGE = "package %s;";

  protected JClassType interfaceType(TypeOracle oracle, String s, TreeLogger treeLogger) throws UnableToCompleteException {
    JClassType interfaceType;
    try {
      interfaceType = oracle.getType(s);
    } catch (NotFoundException e) {
      treeLogger.log(TreeLogger.ERROR, String.format("%s: Could not find the interface [%s]. %s", e.getClass().getName(), s, e.getMessage()));
      throw new UnableToCompleteException();
    }
    return interfaceType;
  }

  @Override
  public String generate(TreeLogger treeLogger, GeneratorContext generatorContext, String s) throws UnableToCompleteException {
    JClassType interfaceType = interfaceType(generatorContext.getTypeOracle(), s, treeLogger);

    String packageName = interfaceType.getPackage().getName();
    PrintWriterManager writers = new PrintWriterManager(generatorContext, treeLogger, packageName);
    String implName = interfaceType.getName().replace(".", "_") + "Impl";
    PrintWriter printWriter = writers.tryToMakePrintWriterFor(implName);
    if (printWriter != null) {
      IndentedWriter writer = new IndentedWriter(printWriter);
      writer.write(String.format(PACKAGE, packageName));
      writer.newline();
      doGenerate(interfaceType, implName, writer);
      writers.commit();
    }
    return packageName + "." + implName;
  }

  protected abstract void doGenerate(JClassType interfaceType, String implName, IndentedWriter writer);

  protected void writeClassIntro(JClassType interfaceType, String implName, IndentedWriter writer) {
    writer.write("public class %1$s implements %2$s {", implName, interfaceType.getName());
    writer.indent();
    writer.newline();
  }

  protected JParameter[] extractInterfaceMethodParams(JClassType interfaceType) {
    return interfaceType.getImplementedInterfaces()[0].getMethods()[0].getParameters();
  }

  protected void writeOutro(IndentedWriter writer) {
    writer.outdent();
    writer.write("}");
    writer.outdent();
    writer.write("}");
  }
}

FormBinderGenerator.java

package eu.jdevelop.gwt.anno.ui.forms.generator;

import com.google.gwt.core.client.GWT;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.uibinder.rebind.IndentedWriter;
import eu.jdevelop.gwt.anno.client.ui.forms.FormField;
import eu.jdevelop.gwt.anno.ui.BaseGenerator;

/**
 * Generate the Class-Framework for all Annotations
 * which are implementing the FormBinder-interface.
 *
 * @author Siegfried Bolz
 * @since 09.01.2010
 */
public class FormBinderGenerator extends BaseGenerator {

  @Override
  protected void doGenerate(JClassType interfaceType, String implName, IndentedWriter writer) {
    JParameter[] methodParams = extractInterfaceMethodParams(interfaceType);
    writeImports(writer, methodParams);
    writeClassIntro(interfaceType, implName, writer);
    writeFieldsIntro(writer);
    writeMethodIntro(writer, methodParams);
    writeFieldsBinding(interfaceType, writer);
    writeOutro(writer);
  }

  /**
   * Generate default code for all generated Components
   *
   * @param interfaceType
   * @param writer
   */
  private void writeFieldsBinding(JClassType interfaceType, IndentedWriter writer) {
    for (JField jField : interfaceType.getEnclosingType().getFields()) {
      FormField annotation = jField.getAnnotation(FormField.class);
      if(annotation != null) {
        writer.write("component.%1$s = new %2$s();", jField.getName(), jField.getType().getQualifiedSourceName());
        writer.write("component.%1$s.setStyleName("%2$s");", jField.getName(), annotation.styleName());
        writer.write("GWT.log("Adding Field: %1$s of Type: %2$s to: %3$s",null);", jField.getName(), jField.getType().getQualifiedSourceName(), annotation.parentAccessor());
        writer.write("component.%1$s.add(component.%2$s);", annotation.parentAccessor(), jField.getName());
        FieldGeneratorFactory.getInstance().createFor(jField).write(jField, annotation, writer);
      }
    }
  }

  private void writeMethodIntro(IndentedWriter writer, JParameter[] parameters) {
    writer.write("public void bind(%1$s component) {", parameters[0].getType().getQualifiedSourceName());
    writer.indent();
  }

  private void writeFieldsIntro(IndentedWriter writer) {
    // nothing to do now
    writer.newline();
  }

  private void writeImports(IndentedWriter writer, JParameter[] parameters) {
    writer.write(IMPORT, GWT.class.getName());
    //writer.write(IMPORT, parameters[1].getType().getQualifiedSourceName());
    writer.newline();
  }

}

FieldGenerator.java

package eu.jdevelop.gwt.anno.ui.forms.generator;

import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.uibinder.rebind.IndentedWriter;
import eu.jdevelop.gwt.anno.client.ui.forms.FormField;

/**
 * Extend this abstract class to create a FieldGenerator.
 *
 * @author Siegfried Bolz
 * @since 09.01.2010
 */
public abstract class FieldGenerator {
  public abstract void write(JField jField, FormField annotation, IndentedWriter writer);

}

In this class i am adding a specific operation only for the TextBox.

TextFieldGenerator.java

package eu.jdevelop.gwt.anno.ui.forms.generator;

import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.uibinder.rebind.IndentedWriter;
import eu.jdevelop.gwt.anno.client.ui.forms.FormField;

/**
 * Generates additional Code only for the TextBox
 *
 * @author Siegfried Bolz
 * @since 09.01.2010
 */
public class TextFieldGenerator extends FieldGenerator {

  @Override
  public void write(JField jField, FormField annotation, IndentedWriter writer) {
    writer.write("component.%1$s.setEnabled(true);", jField.getName());
    writer.write("component.%1$s.setText("%2$s");", jField.getName(), annotation.defaultText());
    writer.write("component.%1$s.setName("%1$s");", jField.getName());
  }

  private boolean isInstanceOf(JField jField, final Class<?> aClass) {
    try {
      return aClass.isAssignableFrom(Class.forName(jField.getType().getQualifiedSourceName(), false, this.getClass().getClassLoader()));
    } catch (ClassNotFoundException e) {
      throw new RuntimeException(e);
    }
  }
}

In this class i am adding a specific operation only for the Label.

LabelFieldGenerator.java

package eu.jdevelop.gwt.anno.ui.forms.generator;

import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.uibinder.rebind.IndentedWriter;

import eu.jdevelop.gwt.anno.client.ui.forms.FormField;

/**
 * Generates additional Code only for the Label
 *
 * @author Siegfried Bolz
 * @since 09.01.2010
 */
public class LabelFieldGenerator extends FieldGenerator {

	@Override
	public void write(JField jField, FormField annotation, IndentedWriter writer) {
		writer.write("component.%1$s.setText("%2$s");", jField.getName(), annotation.defaultText());
	}

	private boolean isInstanceOf(JField jField, final Class<?> aClass) {
		try {
			return aClass.isAssignableFrom(Class.forName(jField.getType()
					.getQualifiedSourceName(), false, this.getClass().getClassLoader()));
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		}
	}
}

To create a relation between the Fields and the Generators, i am using the FieldGeneratorFactory.

FieldGeneratorFactory.java

package eu.jdevelop.gwt.anno.ui.forms.generator;

import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.TextBox;

import java.util.HashMap;
import java.util.Map;

/**
 * Register all Generators.
 *
 * @author Siegfried Bolz
 * @since 09.01.2010
 */

public class FieldGeneratorFactory {
  private static final FieldGeneratorFactory INSTANCE = new FieldGeneratorFactory();
  private static final Map<String, FieldGenerator> generators = new HashMap<String, FieldGenerator>();
  static {
    generators.put(TextBox.class.getName(), new TextFieldGenerator());
    generators.put(Label.class.getName(), new LabelFieldGenerator());
  }

  private FieldGeneratorFactory() {
  }

  public static FieldGeneratorFactory getInstance() {
    return INSTANCE;
  }

  public FieldGenerator createFor(JField jField) {
    String className = jField.getType().getQualifiedSourceName();
    FieldGenerator generator = generators.get(className);
    if(generator == null) {
      throw new IllegalArgumentException("Did not find any generator for the [" + className +"].");
    }
    return generator;
  }

}

The last class is used to write the Java-Files.

PrintWriterManager.java

package eu.jdevelop.gwt.anno.ui;

import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.TreeLogger;

import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Set;

/**
 * Write the generated Java files.
 *
 * @author Siegfried Bolz
 * @since 09.01.2010
 */
public class PrintWriterManager {
  private final GeneratorContext genCtx;
  private final String packageName;
  private final TreeLogger logger;
  private final Set<PrintWriter> writers = new HashSet<PrintWriter>();

  public PrintWriterManager(GeneratorContext genCtx, TreeLogger logger,
      String packageName) {
    this.genCtx = genCtx;
    this.packageName = packageName;
    this.logger = logger;
  }

  /**
   * Commit all writers we have vended.
   */
  public void commit() {
    for (PrintWriter writer : writers) {
      genCtx.commit(logger, writer);
    }
  }

  /**
   * @param name classname
   * @return the printwriter
   * @throws RuntimeException if this class has already been written
   */
  public PrintWriter makePrintWriterFor(String name) {
    PrintWriter writer = tryToMakePrintWriterFor(name);
    if (writer == null) {
      throw new RuntimeException(String.format("Tried to write %s.%s twice.", packageName, name));
    }
    return writer;
  }

  /**
   * @param name classname
   * @return the printwriter, or null if this class has already been written
   */
  public PrintWriter tryToMakePrintWriterFor(String name) {
    PrintWriter writer = genCtx.tryCreate(logger, packageName, name);
    if (writer != null) {
      writers.add(writer);
    }
    return writer;
  }
}

The last thing to do, is to create the module-file FormBinder.gwt.xml and insert it into the project module file GwtAnnotations.gwt.xml

FormBinder.gwt.xml

<module>
    <inherits name="com.google.gwt.resources.Resources" />

    <generate-with class="eu.jdevelop.gwt.anno.ui.forms.generator.FormBinderGenerator">
        <when-type-assignable class="eu.jdevelop.gwt.anno.client.ui.forms.FormBinder" />
    </generate-with>
</module>

Here you can see the whole project opened in Eclipse.

Open Eclipse Project

Launched Application in Chrome

Debug Window

package eu.jdevelop.gwt.anno.client;

import com.google.gwt.core.client.GWT;

public class MyPanel_InternalFormBinderImpl implements MyPanel.InternalFormBinder {

  public void bind(eu.jdevelop.gwt.anno.client.MyPanel component) {
    component.labelField = new com.google.gwt.user.client.ui.Label();
    component.labelField.setStyleName("GWTstyleLabel");
    GWT.log("Adding Field: labelField of Type: com.google.gwt.user.client.ui.Label to: verticalPanel",null);
    component.verticalPanel.add(component.labelField);
    component.labelField.setText("Hello World Label");
    component.nameField = new com.google.gwt.user.client.ui.TextBox();
    component.nameField.setStyleName("GWTstyleTextBox");
    GWT.log("Adding Field: nameField of Type: com.google.gwt.user.client.ui.TextBox to: verticalPanel",null);
    component.verticalPanel.add(component.nameField);
    component.nameField.setEnabled(true);
    component.nameField.setText("Hello World TextBox");
    component.nameField.setName("nameField");
  }
}

Conclusion

Using Generators can help you to clean up your code by getting rid of boilerplate code. Don’t waste time by writing the same stuff, just generate it. One positive aspect is, that you have one point to make changes and don’t have to refactor the whole project. Ok you could use a factory with static methods (like WidgetsCreatorHelper.createLabelField(String name, String styleName) ), but this is old school and not so beautiful like Annotations.

Technorati Tags: annotation, boilerplate code, eclipse, field, generate, generators, gwt 2.0, Java, label, labelfieldgenerator, printwriter, textbox, textfieldgenerator

• Compilation time
• API changes
• Startup time of the new Development Mode
• Problems with other libraries

My enterprise project currently needs 66 seconds to build 8 permutations and is using this technologies:

• GWT 1.7.1
• GXT 2.1.0
• GIN 1.0 (with Guice 2.0)
• GWT-Presenter 1.0.0
• GWT-Log 2.6.2
• gwtrpc-spring 1.01
• Spring Framework 2.5.6
• Spring Security 2.0.5
• Hibernate Libs 3.x (core, annotation, validator…)

GWT 2.0

After i have replaced the old gwt-jar files with the new files, cleaned the project, i started the build target and launched the application. Here are the results:

Compilation time
Without compiler optimization the build need 107 seconds for 8 permutations. Using the draftCompile parameter the build needs “only” 82 seconds. These are not the results i have awaited.

API changes
Due to the fact that my build runs through without any errors or warnings, i think the major switch from listener to handler was done with the migration vom GWT 1.5 to 1.6 . So i think there aren’t any critical showstoppers waiting for me.

Startup time of the new Development Mode
Changing from com.google.gwt.dev.HostedMode to com.google.gwt.dev.DevMode was a great speedup! Using any browser you want, instead of this old Hosted Mode-Browser is a useful improvement. I can strongly recommend google Chrome 4 with the new Speed Tracer for development.

Problems with other libraries
In the technology-list above you can see that i use a wide range of gwt-technologies. I had some doubts about GXT, because i am using many widgets from it like the TabPanel, Drag and Drop, special Layouts, TreePanels, Accordion Window, Grids… , but i did not noticed any errors! I launched my Selenium-Tests many times and every result was green. The people from GXT have done a good job with the recently released version 2.1.0 .


Conclusion
Overall i think that migration could be possible with less effort if you have implemented an extensive test-suite. I see the most problems in Widget libraries like GXT, SmartGwt.. which are using listeners from API 1.5 .

If you have any comments, drop a line below.

Technorati Tags: compilation time, draftcompile, experience, gin, Google Web Toolkit, Guice, gwt 1.7.1, gwt 2.0, gwt-log, gxt, migrating, presenter

Update: Works perfectly with the new IDEA 10 ! Have a lot of fun with it :)

The IDEA-Plugin EclipseMode, originally developed by Alexey Efimov for the Java-IDE IntelliJ IDEA, is useful for activating incremental compilation (well-known from Eclipse). It is working fine for IDEA 8 but not for IDEA 9. So i have fixed a bug in this plugin and it is now working with IDEA 9.0 Beta and IDEA 92.65.

Installation

Download and extract the plugin-archive into the IDEA 9-Subdirectory plugins.

Plugins-Directory

Start IDEA 9 and open the Application Settings (press STRG+ALT+S). Navigate to plugins and search there for EclipseMode. Activate it and restart IDEA.

IDEA 9 Settings

Open again the Application Settings and you see inside the IDE Settings the new entry Eclipse Mode. Activate it.

Enable incremental compilation

When you now change any class and save it, it will be immediately compiled. Errors are shown inside the Messages-Window.

Plugin Example

That’s it. If you have any comments, drop a line below.

Technorati Tags: bug fixed, eclipse mode, EclipseMode, incremental compilation, intellij idea 9, plugin

Table of contents

• Create the Project-files
• Using Eclipse
• Using NetBeans
• Using IntelliJ IDEA

Create the Project-files

During my growing experience with GWT i learned that it is better to create the project from scratch and import it into the IDE rather then using a IDE-wizard which often creates not all files you need. So let’s start bei downloading the Google Web Toolkit Archive and extract it. Open a shell (Windows-User run “cmd“) and navigate to the directory where you have extracted the GWT-archive. Run the following commands:

• webAppCreator.cmd -out MyProjectDirectory eu.jdevelop.gwt.MyApp
• i18nCreator.cmd -eclipse MyGwtProject -createMessages -out MyProjectDirectory eu.jdevelop.gwt.client.constants.i18n.MyLanguageConstants

So what have you done? You have created a GWT-Project and added support for Eclipse and internationalization (i18n).

Create the Project

• ant build
• ant hosted

Running Ant targets

Hosted Mode

Eclipse Plugin

Import GWT Project

Import project

Eclipse with GWT-Project

Project properties

Launch the application

Install the NetBeans Plugin

Web Application

Directory

Server

GWT Framework

GWT4NB Project

Running in Tomcat

App in Chrome

Change the directory

Original build.xml

Changed build.xml

Search and replace

new ant targets

Copied content

Edit the i18n-file

Hosted mode in NetBeans

IDEA Project

Import project

Select Eclipse

Eclipse directory

Choose project

Use the same directory

Created IDEA project

Tomcat Server

Fix the problem

Launched Tomcat

Tomcat and Chrome 4

hosted mode target

Technorati Tags: create project, eclipse, Google Web Toolkit, gwt, i18n, import, intellij idea, NetBeans

Circular reference problem

public class Server {
  private final Client client;

  public Server(Client client) {
  	this.client = client;
  }
}

Client.java

public class Client {
  private final Server server;

  public Client(Server server) {
  	this.server = server;
  }
}

Both Server and Client refer to the same instances of each other, using Constructor-Injection. Server refers to Client, which refers back to Server in a circle.


The solution for Spring

As you can see, you can’t directly use constructor wiring to make circular referents point to one another. To break the circularity without affecting the overall semantic of interdependence, is to introduce a proxy. First you have to decouple the Server and Client with interfaces.


Server.java

public interface Server{
}

Client.java

public interface Client {
}

ServerImpl.java

public class ServerImpl implements Server {
  private final Client client;

  public ServerImpl(Client client) {
  	this.client = client;
  }
}

ClientImpl.java

public class ClientImpl implements Client {
  private final Server server;

  public ClientImpl(Server server) {
  	this.server = server;
  }
}

The dependencies of ServerImpl and ClientImpl are now on a contract (interface) of each other, rather than a concrete class. This is where the proxy comes in:

ServerProxy.java

public class ServerProxy implements Server {
  private Server delegate;

  public void setDelegate(Server delegate) {
    this.delegate = delegate;
}

The ServerProxy is wired with setter injection, allowing ServerImpl and ClientImpl to declare their fields immutable and use constructor injection.


This is the corresponding Spring-Configuration:

applicationContext.xml

<beans>
		<bean id="serverProxy" class="ServerProxy">
				<property name="delegate" ref="host" />
	  </bean>

	  <bean id="server" class="ServerImpl">
				<constructor-arg ref="client"/>
	  </bean>

	  <bean id="client" class="ClientImpl">
				<constructor-arg ref="serverProxy"/>
	  </bean>
</beans>

The solution for Guice

Solving the circular reference problem with Guice is similar to Spring. All you need is to configure your bindings.

MyModule.java

public class MyModule extends AbstractModule {

  @Override
  public void configure() {
    bind(Server.class).to(ServerImpl.class).in(Singleton.class);
    bind(Client.class).to(ClientImpl.class).in(Singleton.class);
  }
}

The Guice injector automatically provides the proxy so that the correct order of the construction would be guaranteed.

That’s it

Technorati Tags: circular reference dependencies, google guice, Java, Spring

• NetBeans.org
• http://blogs.sun.com/theaquarium/

Now you can read the latest infos when you are on the road


This application has the following functionalities:

• Read the message-description inside the application
• Open the message-url inside the application or with the safari browser
• The possibility to the change the two Feed-URLs

You can download this application for free  


Here are some screenshots

Program Icon

The NetBeans-Feed

Read the Message Description

Loading News inside the app

News loaded inside the app

The Aquarium Feed

The Settings View

Change Feed-URL

Restore default Settings

About View

Technorati Tags: app store, free app, glassfish feed, iPhone, netbeans feed, rss reader