Once you download the doc, if you attempt to open it, it says “File Not Recognized”. So you have to navigate to Google Docs, and upload the file manually. I would like for the CR48 to automatically take you to the Google Docs and upload the doc directly from the link I click.

Class was a breeze and I really enjoyed taking notes, a couple of times I got disconnected from the doc but the CR48 seemed to handle it OK. The only negative I had was that at some point the touch-pad decided to go into highlight mode and it took me a few minutes of fiddling to get it back to normal. Overall class was a very pleasant experience with the CR48 another WIN

Later in the afternoon I took some pictures of a painting I drew and had the need to make some adustments to the image I used Picknic an online photo editing app to make the changes needed. The first problem I had was trying to get the images onto the machine. Although the CR48 comes with a USB Port and an SD Card slot pluggin media into either of these did not make a difference.

After poking around the Internet I had found out that to enable file browsing I had to enable a special flag located in about:flags. Once I enabled advanced file access I was able to see the SDK and to upload the picture to Picknic. I successfully edited the picture and was able to upload it to Facebook.

So far so good, I did not enjoy the video playing but I think it has more to do with the hardware in the CR48 than the OS.

Yesterday to my surprise I received a CR48 from Google; for those not familiar with what this is, its a prototype laptop that Google sent out to a group of people for testing their new cloud operating system Chrome OS.

As a tester I made the commitment of using the CR48 “exclusively” for 30 days. The reason why the exclusively is in quotes is because I can’t reasonably use it for programming windows forms application, something that is required of me at work. But for any other activity I will attempt to use the cloud based CR48.

Today was the first full day I had with the laptop, I was able to transition my Google Apps account to be used with the laptop and I was able to get all my Google services loaded into it.

I experienced my first problem in the afternoon while watching a YouTube video, the sound started making static noises and became unbearable. Apparently this is a known issue. Besides this I did not encounter I that I could not do. So far so good.

I won’t go int too much detail at the moment, in future posts I will make sure to revisit everything shown here. This is more or less a test

“No major systems language has emerged in over a decade, but over that time the computing landscape has changed tremendously”

GOlang takes a fresh spin at something we are all familiar with, it does it with class and performance. I have recently had the chance to delve into the intricacies of GO for class and decided to dedicated part of my blog to it as a resource for future programmers.

I have acquired the ONLY GO Programming book available and will be posting a review shortly. I will also start to develop a library of simple examples to help everyone out!

GO’s official site is located at http://golang.org

The book which has been facilitated to me can be found at http://www.goprogrammingbook.com/

As you probably saw either on Google, my site or any of the thousands of sites that reported it. In order to celebrate Pacmas 30th anniversary the folks at our favorite company Google, made their first ever animated doodle which let you play Pacman with its original sounds and levels. The blog at rescuetime.com has speculated that this awesome little stunt may have cost us $298,803,988.

If we take Wolfram Alpha at its word, Google had about 504,703,000 unique visitors on May 23. If we assume that our userbase is representative, that means:

• Google Pac-Man consumed 4,819,352 hours of time (beyond the 33.6m daily man hours of attention that Google Search gets in a given day)
• $120,483,800 is the dollar tally, If the average Google user has a COST of $25/hr (note that cost is 1.3 – 2.0 X pay rate).
• For that same cost, you could hire all 19,835 google employees, from Larry and Sergey down to their janitors, and get 6 weeks of their time. Imagine what you could build with that army of man power.
• $298,803,988 is the dollar tally if all of the Pac-Man players had an approximate cost of the average Google employee.

I don’t believe this numbers to be anywhere near accurate and I still appreciate and enjoyed thoroughly what Google did. I wonder if anyone ever calculated how much money we loose on Facebook every day?

As usual Google has chosen to use, it’s logo to honor what could be considered one of the biggest games of all times. However, this time there is a twist. If you stay in the page long enough and click around. The doodle comes alive allowing you to control the pacman and play the game with the original sounds and all.

The interactive doodle — a first for Google — is the brainchild of senior user experience designer Marcin Wichary, whose earliest exposure to Pac-Man came at age five while traveling across his native Poland with his father, a game technician, to repair arcade machines. Wichary worked with Google doodler (yes, it’s a real job) Ryan Germick to create the finished design. more…

This right here, is why I love Google!

Update: Google has just posted an entry on their blog about the pacman game and its significance.

When I was growing up, my dad had the best job I could possibly imagine: he was an arcade game and pinball technician. For me, that meant summer trips through Poland’s coastal cities with their seasonal arcade parlors; peeking inside cabinets to learn programming and engineering secrets; and—of course—free games!

One of my favorites was PAC-MAN, whose popularity transcended the geopolitical barriers of that time. During the heyday of space shooters, Tōru Iwatani’s creation stood out as one of the first video games aimed at a broader audience, with a cute story of pizza-shaped character gobbling dots in a maze, colorful (literally!) characters, friendly design, very little violence and everlasting fun.

Today, on PAC-MAN’s 30th birthday, you can rediscover some of your 8-bit memories—or meet PAC-MAN for the first time—through our first-ever playable Google doodle. To play the game, go to google.com during the next 48 hours (because it’s too cool to keep for just one day) and either press the “Insert Coin” button or just wait for a few seconds.

Google doodler Ryan Germick and I made sure to include PAC-MAN’s original game logic, graphics and sounds, bring back ghosts’ individual personalities, and even recreate original bugs from this 1980’s masterpiece. We also added a little easter egg: if you throw in another coin, Ms. PAC-MAN joins the party and you can play together with someone else (PAC-MAN is controlled with arrow keys or by clicking on the maze, Ms. PAC-MAN using the WASD keys).

The first thing you’ll need to download and add to your project is the google GSON library http://code.google.com/p/google-gson/downloads/list

Add the jar file to your android project as an external jar

Download the following WebService.java class in order to interact with the web service and add it to your project

package josecgomez.com.android.dev.webservice;

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.util.Map;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.params.ClientPNames;
import org.apache.http.client.params.CookiePolicy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;
import org.json.JSONException;
import org.json.JSONObject;

import android.util.Log;

import com.google.gson.Gson;

public class WebService{

    DefaultHttpClient httpClient;
    HttpContext localContext;
    private String ret;

    HttpResponse response = null;
    HttpPost httpPost = null;
    HttpGet httpGet = null;
    String webServiceUrl;

    //The serviceName should be the name of the Service you are going to be using.
    public WebService(String serviceName){
        HttpParams myParams = new BasicHttpParams();

        HttpConnectionParams.setConnectionTimeout(myParams, 10000);
        HttpConnectionParams.setSoTimeout(myParams, 10000);
        httpClient = new DefaultHttpClient(myParams);
        localContext = new BasicHttpContext();
        webServiceUrl = serviceName;

    }

    //Use this method to do a HttpPost\WebInvoke on a Web Service
    public String webInvoke(String methodName, Map<String, Object> params) {

    	JSONObject jsonObject = new JSONObject();

    	for (Map.Entry<String, Object> param : params.entrySet()){
    		try {
    			jsonObject.put(param.getKey(), param.getValue());
			}
    		catch (JSONException e) {
    			Log.e("Groshie", "JSONException : "+e);
			}
    	}
        return webInvoke(methodName,  jsonObject.toString(), "application/json");
    }

    private String webInvoke(String methodName, String data, String contentType) {
        ret = null;

        httpClient.getParams().setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.RFC_2109);

        httpPost = new HttpPost(webServiceUrl + methodName);
        response = null;

        StringEntity tmp = null;        

        //httpPost.setHeader("User-Agent", "SET YOUR USER AGENT STRING HERE");
        httpPost.setHeader("Accept",
"text/html,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5");

        if (contentType != null) {
            httpPost.setHeader("Content-Type", contentType);
        } else {
            httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");
        }

        try {
            tmp = new StringEntity(data,"UTF-8");
        } catch (UnsupportedEncodingException e) {
            Log.e("Groshie", "HttpUtils : UnsupportedEncodingException : "+e);
        }

        httpPost.setEntity(tmp);

        Log.d("Groshie", webServiceUrl + "?" + data);

        try {
            response = httpClient.execute(httpPost,localContext);

            if (response != null) {
                ret = EntityUtils.toString(response.getEntity());
            }
        } catch (Exception e) {
            Log.e("Groshie", "HttpUtils: " + e);
        }

        return ret;
    }

    //Use this method to do a HttpGet/WebGet on the web service
    public String webGet(String methodName, Map<String, String> params) {
    	String getUrl = webServiceUrl + methodName;

    	int i = 0;
    	for (Map.Entry<String, String> param : params.entrySet())
    	{
    		if(i == 0){
    			getUrl += "?";
    		}
    		else{
    			getUrl += "&";
    		}

    		try {
				getUrl += param.getKey() + "=" + URLEncoder.encode(param.getValue(),"UTF-8");
			} catch (UnsupportedEncodingException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

    		i++;
    	}

        httpGet = new HttpGet(getUrl);
        Log.e("WebGetURL: ",getUrl);

        try {
            response = httpClient.execute(httpGet);
        } catch (Exception e) {
            Log.e("Groshie:", e.getMessage());
        }

        // we assume that the response body contains the error message
        try {
            ret = EntityUtils.toString(response.getEntity());
        } catch (IOException e) {
            Log.e("Groshie:", e.getMessage());
        }

        return ret;
    }

    public static JSONObject Object(Object o){
    	try {
			return new JSONObject(new Gson().toJson(o));
		} catch (JSONException e) {
			e.printStackTrace();
		}
		return null;
    }

    public InputStream getHttpStream(String urlString) throws IOException {
        InputStream in = null;
        int response = -1;

        URL url = new URL(urlString);
        URLConnection conn = url.openConnection();

        if (!(conn instanceof HttpURLConnection))
            throw new IOException("Not an HTTP connection");

        try{
            HttpURLConnection httpConn = (HttpURLConnection) conn;
            httpConn.setAllowUserInteraction(false);
            httpConn.setInstanceFollowRedirects(true);
            httpConn.setRequestMethod("GET");
            httpConn.connect(); 

            response = httpConn.getResponseCode();                 

            if (response == HttpURLConnection.HTTP_OK) {
                in = httpConn.getInputStream();
            }
        } catch (Exception e) {
            throw new IOException("Error connecting");
        } // end try-catch

        return in;
    }

    public void clearCookies() {
        httpClient.getCookieStore().clear();
    }

    public void abort() {
        try {
            if (httpClient != null) {
                System.out.println("Abort.");
                httpPost.abort();
            }
        } catch (Exception e) {
            System.out.println("Your App Name Here" + e);
        }
    }
}

Based on the structure of your JSON file develop a class in your project to support the structure. For example for the above mentioned service I developed this class.

The JSON returned has this structure {“alertid”:”1″,”alerttext”:”This is test”,”alertdate”:”2010-02-11 09:03:40″}

package josecgomez.com.android.dev.webservice.objects;

public class alerts {

	public int alertid;
	public String alerttext;
	public String alertdate;

	@Override
	public String toString()
	{
		return "Alert ID: "+alertid+ " Alert Text: "+alerttext+ " Alert Date: "+alertdate;

	}
}

Once you’ve done this in your android activity you may execute the following code to access the web service

 // Instantiate the Web Service Class with he URL of the web service not that you must pass

        WebService webService = new WebService("http://www.sumasoftware.com/alerts/GetAlerts.php");

        //Pass the parameters if needed , if not then pass dummy one as follows
		Map<String, String> params = new HashMap<String, String>();
		params.put("var", "");

		//Get JSON response from server the "" are where the method name would normally go if needed example
		// webService.webGet("getMoreAllerts", params);
		String response = webService.webGet("", params);

		try
		{
			//Parse Response into our object
			Type collectionType = new TypeToken<List<alerts>>(){}.getType();
			List<alerts> alrt = new Gson().fromJson(response, collectionType);

		}
		catch(Exception e)
		{
			Log.d("Error: ", e.getMessage());
		}

Please note that the above code is for accessing collection of items, if you are attempting to access a single item there should be a slight modification to the code as follows

/* Replace
Type collectionType = new TypeToken<List<alerts>>(){}.getType();
List<alerts> alrt = new Gson().fromJson(response, collectionType);
with
*/
alerts alert = new Gson().fromJson(response, alerts.class);

The above method uses GET if you need to INVOKE POST there should be a slight modification to the above code as follows. I hope this helps.

/* Replace
String response = webService.webGet("", params);
with
*/
webService.webInvoke("", params);