According to the Crypto docs, the arguments for the sign method are an algorithm name (i.e., RSA-SHA1), an input Blob (the string to encrypt) and a privateKey Blob. The value of privateKey must be decoded using the EncodingUtilbase64Decode method, and should be in RSA’s PKCS #8 (1.2) Private-Key Information Syntax Standard form.

The sample code from the docs doesn’t help determining how to obtain the privateKey:

1
2
3
4
5

String algorithmName = 'RSA';
String key = 'pkcs8 format private key';
Blob privateKey = EncodingUtil.base64Decode(key);
Blob input = Blob.valueOf('12345qwerty');
Crypto.sign(algorithmName, input, privateKey);

So after a couple of days of trial and error, swearing and sticking needles in my eyes, I finally came up with the solution for Google. It may not apply to other services but the methodology is roughly the same for the privateKey.

The first step is to generate a self-signing public certificate and private key. You can find more info here. Open terminal and run the following:

openssl req -x509 -nodes -days 365 -newkey rsa:1024 -shal -subj ‘/C=US/ST=CA/L=San Mateo/CN=www.appirio.com’ -keyout key-mycompanyrsa.pem -out cert-mycompanyrsa.pem

This will spit out a cert file (cert-mycompanyrsa.pem) and private key file (key-mycompanyrsa.pem). Then upload the cert to your domain for the Google account. This will generate a consumer key and a consumer secret for your application.

Now here was my mistake. I was opening the private key file (key-mycompanyrsa.pem) and using the contents of this file in my Apex code for the privateKey Blob value. Google was choking when creating the OAuth request token saying that the signature was incorrect: signature_invalid.

Here’s the fix. You need to use the private key file (key-mycompanyrsa.pem) with the openssl pkcs8 command to process the private keys into PKCS#8 format.

Open terminal again and run:

openssl pkcs8 -topk8 -nocrypt -in key-mycompanyrsa.pem -outform PEM

This will display a new private key in terminal and THIS is the value you use for the privateKey argument for the sign method. Just copy everything betweek the “begin” line and “end” line.

I think Quinton Wall and Kris Muller did an awesome job with this demo. Quinton spent most of his time at Google I/O working the Developer Sandbox so it was good to see that Salesforce had such great representation at the event. Even Dave Carroll graced the event with his presence. Every time I stopped by the booth they were busy giving demos. I know the Wave Team was very happy with the presentation and I overhead them talking very positively about it.

The use case for the demo was perfect. You have a team working an Opportunity and quickly want to start up a wave to begin collaborating on strategies to close it. With essentially one click you can spin up a wave with all team members and attach it to the Opportunity for historical reference. You can even invite resources from outside your domain to collaborate. The cool part of the demo is that Wave can then post updates to the Chatter feed using OAuth. I wanted to do something similar with Wave a couple of months ago about but was not able to since, at that time, a robot was not able to add participants. Glad to see that when the new Robots API v2 came out, Quinton was able to make this happen. Kudos to Quinton! Great job!

Scroll into minute 19 to see the start of the Salesforce portion of the demo. For more info on the toolkit, check out the An Introduction to the Force.com Toolkit for Google Wave.

www.youtube.com/watch?v=q8jjIMGB1Fw

Vic Gundotra (Vice President, Engineering) stated that “I/O” represented “Innovation” and “Openness” and that was the theme throughout the two day event. Google relentlessly bashed Apple for their stance on a number of issues (no Flash, AT&T only, policed App Store, etc) and cemented their “kumbayah” of inclusiveness and standards. Google drove home their support for HTML5, Flash and a new open-source, royalty-free video format called WebM.

The Day 2 Keynote was awesome! One of the most riveting keynotes I’ve ever seen. You’ll definitely want to watch the video below.

www.youtube.com/watch?v=IY3U2GXhz44

Android, Android and more Android
This might have well been called the “Android Developer’s Conference” as most of the emphasis was on their mobile platform. I have to admit that they didn’t disappoint. All of Android sessions and labs were packed and some even turned away people. I attended a couple of hacker sessions including development best practices, game development and building REST clients.

Last year Google gave every attendee a Nexus One at the event. This year they were smart and shipped everyone a Nexus One or Droid a month before the event to help them get up and running on the Android platform. Then, to everyone’s surprise, they gave everyone on day 2 another Android device; the Sprint HTC EVO that ships next month. I’m seriously in love with this phone and am considering giving up my iPhone.

The major announcement was the release of Android 2.2 Froyo (Frozen Yogurt). Some of the highlight include:

• 2-5x speed increase with devices running the Dalvik just-in-time (JIT) compiler
• 2-3x browser speed improvement with the Chrome V8 engine
• Support for Microsoft Exchange
• Flash support
• Tethering and Portable Hotspot
• App Storage on SD -- run app directly from the SD card
• Update All and Auto-update for applications

App Engine for Business
After two years, Google finally announced a service target specifically at small businesses. The service adds management and support features tailored specifically for the enterprise allowing them to take advantage of the core benefits of Google App Engine: easy development using familiar languages (Java and Python); simple administration, with no need to worry about hardware, patches or backups; and effortless scalability. However, some of the details, especially pricing, were fuzzy. My favorite was announced support for SQL databases (presumably MySQL).

• Centralized administration: A new, company-focused administration console lets companies manage all the applications in their domain.
• Reliability and support: 99.9% uptime service level agreement, with premium developer support available.
• Secure by default: Only users from the Google Apps domain can access applications and corporate security policies are enforced on every app.
• Pricing that makes sense: Each application costs just $8 per user, per month up to a maximum of $1000 a month. This is the part I didn’t quite understand as it must be for non-domain users.
• Enterprise features: Coming later this year, hosted SQL databases, SSL on the company’s domain for secure communications, and access to advanced Google services.

Google Wave
Over the last number of months the Wave team has made a number of enhancements to the service. They’ve added an extensions gallery, Robots API v2, Active Robot API and an anonymous read-only access for embedded waves. They made the statement in a number of sessions that if you tried Wave in the past to please come back and take a look at Wave now given the number of enhancements. Google also went so far as to make Wave available for Google Apps (Standard, Premier and Education Editions). Some features announced at I/O include:

• Run robots on any server — not just App Engine. They also announced that you can program robots in Google Go.
• Use a robot to manipulate and retrieve attachments within a wave
• Use the “Wave This” service to let your website’s visitors easily create waves out of the content on your site.
• Fetch waves on behalf of users with Wave data APIs

Google Web Toolkit
GWT sessions were quite numerous and popular and the Day 1 keynote revealed some exciting new features. VMware and Google announced a collaboration centered around the Spring programming model, SpringSource Tool Suite and Spring Roo. The highlights of the announcement include:

• Tight integration with SpringSource Tool Suite and Spring Roo to provide a polished, productive developer experience
• Innovative, close integration between Spring and Google Web Toolkit offering the ability to build rich applications with amazing speed
• The ability to easily target Spring applications to Google App Engine
• A compelling integration between Spring Insight and Google Speed Tracer to provide insight into the performance of Spring applications from browser to database

Google TV
This was the main announcement of the second half of the Day 2 keynote. A lot of people were surprised as there were talks of a Google tablet in the air. The keynote demo was very interesting as they ran into a number of glitches involving Bluetooth connectivity between the keyboard and set top box (no one thought of bringing a standard keyboard with a cable?). The idea is not new but they are bringing together some industry powerhouses (Sony, Intel, Adobe, Best Buy, Logitech and Dish Network) to bring the concept to market by this Christmas. TechCrunch has a really good review of Google TV.

Some other interesting announcements were:

• Google Storage for Developers -- store your data in Google’s cloud
• Chrome Web Store -- an app store for websites
• Google Prediction API -- machine learning algorithms to analyze your historic data and predict likely future outcomes
• WebFont API -- support for web fonts
• Google Buzz API -- access to the Buzz platform
• Latitude API -- a simple way to share your location with whomever you like

So what is PS Connect? PS Connect allows you to use Google Apps as a front end to cloud-based business applications. With our Gmail contextual gadgets you can take actions from inside your Gmail inbox instead of logging into multiple systems.

You can read the full announcement on our website or get more info on PS Connect. If you’d like a deeper dive, you can even sign up for a 30 minute demo.

www.youtube.com/watch?v=sO0gSFBlhrI

So I’m making some assumptions that you already have the GWT SDK and Eclipse Plugin installed and are familiar with both of them. If you are not, take a look at the GWT site for more info.

To get started, create a new Web Application Project called “HelloUiBinder” in the package of your choice but do not check “Use Google App Engine”.

Now create a new UiBinder template and owner class (File -> New -> UiBinder). Choose the client package for the project and then name it MyBinderWidget. Leave all of the other defaults. When you click Finish the plugin will create a new UiBinder template and owner class.

Open the MyBinderWidget.ui.xml template and add the following code. With GWT you can define your styles either in your template where you need them or externally. I’ve added a small style inline that adds some pizzaz to the label. Notice the field name myPanelContent in the template. You can programmatically read and write to this field from the template’s owner class. So when the owner class runs, it construct a new VerticalPanel, does something with it (probably add some type of content) and then fill this field with it.

Attributes for the elements (the text attribute in the Label element for example) correspond to a setter method for the widget. Unfortunately there is no code completion to get a list of these attributes in Eclipse when you hit the space bar so you either have to know the setters or refer to the JavaDocs each time. A painful process.

1
2
3
4
5
6
7
8
9
10
11

<!DOCTYPE ui:UiBinder SYSTEM "http://dl.google.com/gwt/DTD/xhtml.ent">
<ui:UiBinder xmlns:ui="urn:ui:com.google.gwt.uibinder"
     xmlns:g="urn:import:com.google.gwt.user.client.ui">
     <ui:style>
          .bolder { font-weight:bold; }
     </ui:style>
     <g:HTMLPanel>
          <g:Label styleName="{style.bolder}" text="This is my label in bold!"/>
          <g:VerticalPanel ui:field="myPanelContent" spacing="5"/>
     </g:HTMLPanel>
</ui:UiBinder>

For the owner class, MyBinderWidget.java, add the following code. In this class, a field with the same name, myPanelContent, is marked with the @UiField annotation. When uiBinder.createAndBindUi(this) is run, the content is created for the VerticalPanel and the template field is filled with the new instance.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package com.jeffdouglas.client;
 
import com.google.gwt.core.client.GWT;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.google.gwt.user.client.ui.Widget;
 
public class MyBinderWidget extends Composite {
 
     private static MyBinderWidgetUiBinder uiBinder = GWT
               .create(MyBinderWidgetUiBinder.class);
 
     interface MyBinderWidgetUiBinder extends UiBinder<widget, MyBinderWidget> { }
 
     @UiField VerticalPanel myPanelContent;
 
     public MyBinderWidget() {
          initWidget(uiBinder.createAndBindUi(this));
 
          HTML html1 = new HTML();
          html1.setHTML("<a href='http://www.google.com'>Click me!</a>");
          myPanelContent.add(html1);
          HTML html2 = new HTML();
          html2.setHTML("This is my sample <b>content</b>!");
          myPanelContent.add(html2);
 
     }
 
}

Now change the entry point class to look like the following.

1
2
3
4
5
6
7
8
9
10
11
12

package com.jeffdouglas.client;
 
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.RootPanel;
 
public class HelloUiBinder implements EntryPoint {
 
     public void onModuleLoad() {
          MyBinderWidget w = new MyBinderWidget();
          RootPanel.get().add(w);
     }
}

Now open HelloUiBinder.html and remove all of the HTML content between the </noscript> and and </body> save it. Once you run the application, copy the development URL and run paste it into your favorite supported browser, you should see the following.

Now suppose you wanted to nest a widget inside your MyBinderWidget that did something when a button was clicked. We’ll create a small series of checkboxes that allows the user to select their favorite colors and display them when the button is clicked. Create a new UiBinder called FavoriteColorWidget in the client package. Add the following code to the FavoriteColorWidget.ui.xml template.

1
2
3
4
5
6
7
8
9
10
11

<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
    xmlns:g='urn:import:com.google.gwt.user.client.ui'>
    <g:VerticalPanel>
      <g:Label ui:field="greeting"/>
      <g:Label>Choose your favorite color(s):</g:Label>
      <g:CheckBox ui:field="red" formValue="red">Red</g:CheckBox>
      <g:CheckBox ui:field="white" formValue="white">White</g:CheckBox>
      <g:CheckBox ui:field="blue" formValue="blue">Blue</g:CheckBox>
      <g:Button ui:field="button">Submit</g:Button>
    </g:VerticalPanel>
</ui:UiBinder>

Now add the click handler in the FavoriteColorWidget.java owner class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

package com.jeffdouglas.client;
 
import java.util.ArrayList;
import com.google.gwt.core.client.GWT;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.CheckBox;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.Widget;
 
public class FavoriteColorWidget extends Composite {
 
     private static FavoriteColorWidgetUiBinder uiBinder = GWT
               .create(FavoriteColorWidgetUiBinder.class);
 
     interface FavoriteColorWidgetUiBinder extends
               UiBinder<widget, FavoriteColorWidget> {
     }
 
     @UiField Label greeting;
     @UiField CheckBox red;
     @UiField CheckBox white;
     @UiField CheckBox blue;
     @UiField Button button;
 
     public FavoriteColorWidget() {
          initWidget(uiBinder.createAndBindUi(this));
 
          // add a greeting
          greeting.setText("Hello Jeff!!");
 
          final ArrayList<checkBox> checkboxes = new ArrayList<checkBox>();
          checkboxes.add(red);
          checkboxes.add(white);
          checkboxes.add(blue);
 
         // add a button handler to show the color when clicked
          button.addClickHandler(new ClickHandler() {
               public void onClick(ClickEvent event) {
                    String t = "";
                    for(CheckBox box : checkboxes) {
                         // if the box was checked
                         if (box.getValue()) {
                              t += box.getFormValue() + ", ";
                         }
                    }
                    Window.alert("Your favorite color/colors are: "+ t);
               }
          });
 
     }
 
}

The last thing we’ll need to do is add our new widget to the MyBinderWidget template. Open MyBinderWidget.ui.xml and add the custom namespace reference and the FavoriteColorWidget.

1
2
3
4
5
6
7
8
9
10
11
12
13

<!DOCTYPE ui:UiBinder SYSTEM "http://dl.google.com/gwt/DTD/xhtml.ent">;
<ui:UiBinder xmlns:ui="urn:ui:com.google.gwt.uibinder"
     xmlns:g="urn:import:com.google.gwt.user.client.ui"
     xmlns:c="urn:import:com.jeffdouglas.client">
     <ui:style>
          .bolder { font-weight:bold; }
     </ui:style>
     <g:HTMLPanel>
          <g:Label styleName="{style.bolder}" text="This is my label in bold!"/>
          <g:VerticalPanel ui:field="myPanelContent" spacing="5"/>
          <c:FavoriteColorWidget/>
     </g:HTMLPanel>
</ui:UiBinder>

Now when you run the application it should look like the following.

Using JSON RESTful Web Services with Salesforce.com opens up your org to a number third-party integration opportunities (Google, Yahoo!, Flickr, bespoke, etc.). JSON support isn’t baked into the Force.com platform but Ron Hess at Salesforce.com has created a JSON parser which will do the heavy lifting for you.

Last month I wrote a blog post and example of how to call a REST Web Service with Apex that returns and consumes XML. It was my intention to do the same demo using JSON, however, I ran into a small sang. I couldn’t get the Apex JSONObject parser to work. I tried on and off for a couple of days but couldn’t beat it into submission. I checked around the twitter-verse and no one reported much success using the JSON parser with complex objects. I finally cried “uncle” and called Ron and asked for help. Ron was extremely responsive and over the course of a couple of days we worked worked through some of the parsing issues and finally updated the Google project with the changes.

I put together a small demo where you enter your address and the Apex code fetches the address and coordinates from the Google Maps . The service returns the data as a JSON object. You can run this example on my Developer Site.

To get started, you’ll need to download the JSONObject class and install it into a Developer org or Sandbox. Unfortunately there is no documentation for the parser so you have to extrapolate from the json.org website.

You’ll also need to sign up for a Google Maps API key in order to use their geocoding service. I would also recommend that you take a look at the docs for Google Maps geocoding service.

Here is the Controller for the demo. The interesting stuff is in the getAddress() and toGeoResult() methods. In getAddress(), the user-entered address is used to construct the URL for the GET call to the geocoding service. Make sure you properly encode the address or you may receive undesirable results returned from Google. One thing to point out is line #58. Google is returning a line feed in their JSON response which causes the JSON parser to choke. I simply replace all like feeds with spaces and that did the trick. Ron was going to look into making this change to the JSONObject class in the near future.

I was also having some problems with the geocoding service so I hard-coded the returned JSON object for testing. I checked around and it seems to be a common problem that the Google Maps API randomly returns 620 errors when overloaded. You might want to take a look at the JSON response returned for the hard-coded address. I will give you a little insight for the parsing process.

The toGeoResult() method parses the returned JSON response and populates the GeoResult object with the appropriate data. I chose this Google Maps example because it shows how to parse simple values, nested JSON objects and arrays. The coordinates for the address can either be returned as integers or doubles so I have to check each one.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

public class RestDemoJsonController {
 
    public String geoAddress {get;set;}
    public String address {get;set;}
    public String city {get;set;}
    public String state {get;set;}
    public Boolean useGoogle {get;set;}
 
    // google api key
    private String apiKey {get;set { apiKey = 'ABQIAAAAlI0DHB0p0WGX35GrKEAzQhTwZth5GdZI-P7ekoe_gyhfzl1yZhRAYdM-hb7aEWu30fGchcvGuwuUqg'; } }
 
    // method called by the Visualforce page's submit button
    public PageReference submit() {
 
    	if (address.length() == 0) {
    		ApexPages.addMessage(new ApexPages.message(ApexPages.severity.ERROR,'Address cannot be blank'));
    	}
    	if (city.length() == 0) {
    		ApexPages.addMessage(new ApexPages.message(ApexPages.severity.ERROR,'City cannot be blank'));
    	}
    	if (state.length() == 0) {
    		ApexPages.addMessage(new ApexPages.message(ApexPages.severity.ERROR,'State cannot be blank'));
    	}
 
    	if (!ApexPages.hasMessages())
	    	geoAddress = getAddress(address,city,state);
 
    	return null;
    }
 
    // call the geocoding service
	private String getAddress(String street, String city, String state) {
 
		String json;
 
		// hard-coded returned JSON response from Google
		if (useGoogle) {
			json = '{  "name": "1600 Amphitheatre Parkway, Mountain View, CA",  "Status": {    "code": 200,    "request": "geocode"  },  "Placemark": [ {    "id": "p1",    "address": "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA",    "AddressDetails": {   "Accuracy" : 8,   "Country" : {      "AdministrativeArea" : {         "AdministrativeAreaName" : "CA",         "SubAdministrativeArea" : {            "Locality" : {               "LocalityName" : "Mountain View",               "PostalCode" : {                  "PostalCodeNumber" : "94043"               },               "Thoroughfare" : {                  "ThoroughfareName" : "1600 Amphitheatre Pkwy"               }            },         '+
			'   "SubAdministrativeAreaName" : "Santa Clara"         }      },      "CountryName" : "USA",      "CountryNameCode" : "US"   }},    "ExtendedData": {      "LatLonBox": {        "north": 37.4251466,        "south": 37.4188514,        "east": -122.0811574,        "west": -122.0874526      }    },    "Point": {      "coordinates": [ -122.0843700, 37.4217590, 0 ]    }  } ]}	';
 
		// call the geocoding service live
		} else {
 
			HttpRequest req = new HttpRequest();
			Http http = new Http();
			// set the method
			req.setMethod('GET');
			// generate the url for the request
			String url = 'http://maps.google.com/maps/geo?q='+ EncodingUtil.urlEncode(street,'UTF-8')+',+'
				+ EncodingUtil.urlEncode(city,'UTF-8')+',+'
				+ EncodingUtil.urlEncode(state,'UTF-8')
				+'&output=json&sensor=false&key='+apiKey;
			// add the endpoint to the request
			req.setEndpoint(url);
			// create the response object
			HTTPResponse resp = http.send(req);
			// the geocoding service is returning a line feed so parse it out
			json = resp.getBody().replace('\n', '');
 
		}
 
		try {
			JSONObject j = new JSONObject( json );
			return toGeoResult(j).toDisplayString();
		} catch (JSONObject.JSONException e) {
			return 'Error parsing JSON response from Google: '+e;
		}
 
	}
 
	// utility method to convert the JSON object to the inner class
	private GeoResult toGeoResult(JSONObject resp) {
 
		GeoResult geo = new GeoResult();
 
		try {
 
			geo.address = resp.getValue('Placemark').values[0].obj.getValue('address').str;
			geo.keys = resp.keys();
			geo.name = resp.getString('name');
			geo.statusCode = resp.getValue('Status').obj.getValue('code').num;
 
			// set the coordinates - they may either be integers or doubles
			geo.coordinate1 = resp.getValue('Placemark').values[0].obj.getValue('Point').obj.getValue('coordinates').values[0].num != NULL ? resp.getValue('Placemark').values[0].obj.getValue('Point').obj.getValue('coordinates').values[0].num.format() : resp.getValue('Placemark').values[0].obj.getValue('Point').obj.getValue('coordinates').values[0].dnum.format();
			geo.coordinate2 = resp.getValue('Placemark').values[0].obj.getValue('Point').obj.getValue('coordinates').values[1].num != NULL ? resp.getValue('Placemark').values[0].obj.getValue('Point').obj.getValue('coordinates').values[1].num.format() : resp.getValue('Placemark').values[0].obj.getValue('Point').obj.getValue('coordinates').values[1].dnum.format();
			geo.coordinate3 = resp.getValue('Placemark').values[0].obj.getValue('Point').obj.getValue('coordinates').values[2].num != NULL ? resp.getValue('Placemark').values[0].obj.getValue('Point').obj.getValue('coordinates').values[2].num.format() : resp.getValue('Placemark').values[0].obj.getValue('Point').obj.getValue('coordinates').values[2].dnum.format();
 
		} catch (Exception e) {
			// #fail
		}
 
		return geo;
	}
 
	// inner class
	private class GeoResult {
 
		public Set<string> keys;
		public Integer statusCode;
		public String name;
		public String coordinate1;
		public String coordinate2;
		public String coordinate3;
		public String address;
		public String toDisplayString() {
			return address + ' ['
			+ coordinate1 + ', '
			+ coordinate2 + ', '
			+ coordinate3 + '] - Status: '
			+ statusCode;
		}
 
	}
 
}

The Visualforce page is fairly simple and presents the user with a form to enter their address. If the geocoding services is experiencing issues, the user can check “Use hard-coded Google JSON response?” and the Controller with use the hard-coded JSON response instead of making the GET call to the geocoding service. Once submitted, the address is processed and the outputPanel is rerendered with the resulting address and coordinates.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

<apex:page controller="RestDemoJsonController" tabStyle="Contact">
	<apex:sectionHeader title="Google Maps Geocoding" subtitle="REST Demo (JSON)"/>
 
     <apex:form >
     <apex:pageBlock >
 
          <apex:pageBlockButtons >
              <apex:commandButton action="{!submit}" value="Submit"
                   rerender="resultsPanel" status="status"/>
          </apex:pageBlockButtons>
          <apex:pageMessages />
 
          This example calls the Google Map geocoding REST service (JSON) with the address
          you provide below.<p/>
 
          Sometimes the geocoding services stops responding due to service availability. If you are receiving errors
          with the returned JSON object, you can check the "Use hard-coded JSON response" to use a returned JSON
          response hard-coded into the controller from the Googles address.<p/>
 
          <apex:pageBlockSection >
               <apex:pageBlockSectionItem >
                    <apex:outputLabel for="address">Address</apex:outputLabel>
                    <apex:inputText id="address" value="{!address}"/>
               </apex:pageBlockSectionItem>
          </apex:pageBlockSection>
 
          <apex:pageBlockSection >
               <apex:pageBlockSectionItem >
                    <apex:outputLabel for="city">City</apex:outputLabel>
                    <apex:inputText id="city" value="{!city}"/>
               </apex:pageBlockSectionItem>
          </apex:pageBlockSection>
 
          <apex:pageBlockSection >
               <apex:pageBlockSectionItem >
                    <apex:outputLabel for="state">State</apex:outputLabel>
                    <apex:inputText id="state" value="{!state}"/>
               </apex:pageBlockSectionItem>
          </apex:pageBlockSection><br/>
 
          <apex:pageBlockSection >
               <apex:pageBlockSectionItem >
                    <apex:outputLabel for="useGoogle">Use hard-coded Google JSON response?</apex:outputLabel>
                    <apex:inputCheckbox id="useGoogle" value="{!useGoogle}"/>
               </apex:pageBlockSectionItem>
          </apex:pageBlockSection><br/>
 
          <apex:actionStatus id="status" startText="Fetching map..."/>
          <apex:outputPanel id="resultsPanel">
          		<apex:outputText value="{!geoAddress}"/><br/>
          </apex:outputPanel>
 
     </apex:pageBlock>
     </apex:form>
 
</apex:page>

Unit Testing

Writing unit tests for callouts can present a challenge. Scott Hemmeter has a really good article entitled Testing HTTP Callouts which should provide you with some useful techniques. You should also check out An Introduction to Apex Code Test Methods on the developerforce wiki.

I also found this nifty JSON viewer which makes debugging less painful.

The Google Wave Notifier project on SourceForge is maturing and is available for both Windows and Linux (Wine). With the notifier you can:

Here a small video demonstrating some of it’s features. At Appirio we are running our own domain on the Google Wave servers so it will be interesting to see if this notifier supports this feature.

www.youtube.com/watch?v=wEy-83DW4Wk

GWT is used by many products at Google, including Google Wave and Google AdWords. It’s open source, completely free, and used by thousands of developers around the world.

The video below does a really nice feature overview but here are some of my bullet points from the video. You can find more detailed info on the new features here.

• Declarative User Interface – gone are the days of programmatically laying out your application in a Swing type manner. Similar to Adobe Flex, the new UiBinder allows you to lay out your user interface in an XML file and then bind that to a Java class that contains applications logic. This is my favorite new feature!
• Speed Tracer – a new tool that helps you analyze the performance of any web page and understand where the various sources of latency are.
• Easier Styling – with the new UiStyle feature you can write CSS styles and bundle them directly in the template. You get the speed benefit of no extra http roundtrip to fetch an external the stylesheet and prevent name conflicts across your application when using widgets.
• Predictable Performance – provide a consistent look and feel with improved layout panels that behave predictably and load quickly.
• Debug in any Browser – no more requirement to use the embedded browser when debugging Java source code. You can now debug in essentially any browser and use development tools for that browser like Firebug in Firefox.
• Faster Load Times – Developer-guided code splitting allows you to chunk your GWT code into multiple fragments for faster startup.
• Improved IDE Support – the new Eclipse plugin provides support for the UiBinder, client bundling, RPC refactoring, wizards to generate boilerplate code and the new development mode.

There are a ton of additional features and you can check them out here. Download GWT today and get started building some kickass apps!

www.youtube.com/watch?v=uExEw3OVMd0

Luckily there’s a way to do this by duplicating the Gmail Notifier app so that multiple copies are running. Here’s the simple process for a Mac:

1. Right click on the Gmail Notifier application and select “Duplicate”.
2. Right click on the new Gmail Notifier application that you just created and select “Show Package Contents”.
3. Open the Info.plist file in the Contents folder in your favorite text editor (ie TextMate)
4. Find the property called CFBundleIdentifier and change it’s string value from com.google.GmailNotifier to something like com.google.GmailNotifierPersonal.
5. Now save the file and close your text editor.

Now when you start all of the Gmail Notifiers, your menu bar should look like:

If you are using Gmail or Google Apps there is a easy way to manage your Salesforce usernames using address aliases. For instance, if your email address is coolsalesforceguy@gmail.com, you can add a “+” and some sort of identifier to your Gmail address to create unique email addresses that are delivered to your one Gmail inbox. Therefore, you could do things like:

• coolsalesforceguy+prd@gmail.com
• coolsalesforceguy+sandbox1@gmail.com
• coolsalesforceguy+de7@gmail.com
• coolsalesforceguy+customer1prd@gmail.com

You can then set up filters to automatically direct these messages to Trash, apply a label or star, skip the inbox, or forward to another email account.