This cartoon of Dilbert always has always fascinated me. You can never be sure about randomness, since the concept itself of randomness provides uncertainty to the process. A few years ago, I even wrote a post on how to achieve randomness using deterministic methods. Nowadays, entropy can always be improved to obtain a more accurate (in this case would be more appropriate to say "less accurate" instead) result.  This can lead into many philosophical discussions, which are not my purpose.

The traditional approach has been to take contextual information (such as the UNIX time) to create a seed for the algorithm and give more uncertainty to the process. This might be sufficient for 99% of our purposes, but leads to more complex problems: For instance, is easy to determine when a user logged into a system, and if at this time a random number is generated to, at the same time, generate some cryptographic keys, is easy to establish an interval when the user was logged (and therefore being closer to the seed of the random algorithm). Is still difficult to determine accurately the exact time, but definitely not impossible: systems of huge relevance face this problem daily.

Recently a publish in the Android Market Chinese Radicals, a program to learn Chinese. Since I need to choose randomly the Chinese radicals for the program, I decided to use it as a testbed to extend my experiment from 3 years ago. The approach is using some "contextualization" of the seed, and combining it with a probability density function. The explanation can get really complex, but I'll try to summarize:

1. At a certain point of execution, I categorize the accesible memory of the thread where the software is running (size and number of memory blocks). This information is stored and modeled for the density function.
2. Afterwards, I take the UNIX time of the system. I apply a probability distribution to the model saved in the first step, and then combine it with this second point. I store the current time, and apply a first pass.
3. When the generation of the random number is finished, I determine the difference between that time and the time I stored in the step two. Since the memory information saved in the point 1 (the entropy of the system) might differ, this time will likely be different. Then I apply a second pass to generate, with more certainty, the random number.

I have released this generator as a Java .jar. You can include in any Java project (Swing, Blackberry, Android, etc). You can download it from here. It works as follows:

1. Import the jar
2. Import the class com.randomizator.Randomizator, and create an object Randomizator by using Randomizar myObject = new Randomizator();
3. Using randomizator.getInt( interval ) will return you a random number between 0 and the number provided.

So far only the generation of integer values is supported. Please, check it out and let me know what you think.

Since I began to write my own intelligent agent for SCAI (a tournament to develop an AI agent able to play Starcraft) I really got very interested in modeling human intelligence. So of course there is a lot to do in this field, and doesn't make any sense to list those well-known challenges still open. One of the fields that always attracted me was the Sentimental Analysis. How interesting is the idea of extracting sentimental information of texts? Furthermore, this field deeps into many interesting areas of the Artificial Intelligence.

A few months ago I began to develop my own Sentimental Analyzer. It wasn't easy at the beginning: there are so many different approaches that the task seemed overwhelming. Since the project aimed to have a little more impact that traditional sentimental analyzers, I used a different approach: most of the ideas use keywords approach. They are pretty effective, but they do not ensure recall and it is more difficult to train the analyzer (i.e., train it automatically by using Twitter as a learning source). So I decided to use it using classifiers from different machine learning algorithms. The analyzer has been trained only for English, although it learns every day and I'm considering to expand it to some other languages (fundamentally Spanish and German)

And the experiment is working, and pretty accurate I would like to say. I have developed two applications to show them as testbeds for the analyzer:

• The Happinness Observer, which determines the happiness for a certain concept
• City Mood. This application determines the position of the user and throw information of the mood state of the city, based on the tweets from the people referencing it.

Feel free to download the applications and let me know what you think.

Last but not least, I have decided to give free access to the API for those who are interested. The idea is quite simple: you can call to this URL:

http://feeling-analyzer.appspot.com/feeling_analyzer/feeling?text=I+love+this+guy

In the parameter text you should send the text (HTTP codified) you want to analyze. You will need to register for a key to use the application (and add it as a parameter on the same way: &key=providedKey). Drop me a line if you need a key and I will provide you one.

The application return a value corresponding the the polarity of the text: 0 means negative, 2 means neutral and 4 means positive. As a further enhancement of the algorithm I'm planning to extend the polarity of the analysis to support multi-values (i.e., not just providing discret values but a full continuous range of them, from 0 to 100 for example).

Enrique López-Mañas

Reading and thinking the last days about how to implement an intelligent system to play Starcraft, I had time to think about the implications of considering a system "intelligent".

Nowadays, we can develop systems that are able to defeat human intelligence in certain genres. Some board games like chess, or most of the shooters are composed by a limited set of rules, that can be easily modelated and represented with different combination of techniques (an expert system, considering most of the rules for almost all the situations is a typical choice). As my colleague Bruno points out (Spanish link), we even have to limit the intelligence of those systems by applying "stupidifying" techniques. In one of the examples Bruno provides, we only allow the AI to attack the human player after spotting him; leading this into very weird situations like the one exposed in the following video

But this does not apply in strategy games. Generally, a human player has much more capacity for analysis and improvisation in complex systems like strategy games, so the only way to empower the AI is to make it able to cheat (whether in the form of direct benefits, or having access to information that the human player can't access in the same situation). The approach of experts systems, which has been proven to work well in most of the scenarios, can't be applied here: implementing all the possible rules for one single (and simple) situation is an overwhelming task. Cheating AI are a well-known aspect of Sid Meier's Civilization series; in those games, the player must build his empire from scratch, while the computer's empire receives additional units at no cost and is freed from most resource restrictions.

How to solve this? Well, one idea could be to apply learning techniques. In the last AIIDE competition, the Berkeley team designed a special training field, aptly named Valhalla. Instead of manually adjusting the parameters of the AI, they let the AI fight on its own for a high number of iterations, letting it analyzing its own results and adjusting the parameter on its most convenient way. The result can be seen in the following video: they trained a group of mutalisks to massacre their natural counter unit, something unlikely if a human were controlling the units.

But we are still far away from reaching an AI that can defeat humans in complex scenarios. Although its limitations, Moore's law is helping us, but we are not only facing a problem of computing capabilities. We also need to find different ways to model complex scenarios that the human mind is good at analyzing, but the computer is still behind us. And if we finally use cheating to defeat a human intelligence, we have to make it completely transparent: the user will not care as long as beating the AI is still challenging for him.

We first need to register a Twitter App. For that purpose, we will visit the developer website of Twitter. After login in, we will add a new application. There are no special settings to be remembered, but the part of the callback URL has changed very oftenly since Twitter released their API. At the moment, if we are developing one application we only need to provide any random URL.

We need three main classes in our application to make it work.

First, TwitterApp. This will be the controller for the API:

 
 
import java.net.MalformedURLException;
import java.net.URLDecoder;
 
import oauth.signpost.OAuth;
import oauth.signpost.OAuthProvider;
import oauth.signpost.basic.DefaultOAuthProvider;
import oauth.signpost.commonshttp.CommonsHttpOAuthConsumer;
import oauth.signpost.commonshttp.CommonsHttpOAuthProvider;
 
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.User;
 
import android.os.Handler;
import android.os.Message;
 
import android.app.ProgressDialog;
import android.content.Context;
import android.util.Log;
import android.view.Window;
 
import java.net.URL;
 
public class TwitterApp {
	private Twitter mTwitter;
	private TwitterSession mSession;
	private twitter4j.auth.AccessToken mAccessToken;
	private CommonsHttpOAuthConsumer mHttpOauthConsumer;
	private OAuthProvider mHttpOauthprovider;
	private String mConsumerKey;
	private String mSecretKey;
	private ProgressDialog mProgressDlg;
	private TwDialogListener mListener;
	private Context context;
 
	public static final String CALLBACK_URL = "twitterapp://connect";
	private static final String TAG = "TwitterApp";
 
	public TwitterApp(Context context, String consumerKey, String secretKey) {
		this.context	= context;
 
		mTwitter 		= new TwitterFactory().getInstance();
		mSession		= new TwitterSession(context);
		mProgressDlg	= new ProgressDialog(context);
 
		mProgressDlg.requestWindowFeature(Window.FEATURE_NO_TITLE);
 
		mConsumerKey 	= consumerKey;
		mSecretKey	 	= secretKey;
 
		mHttpOauthConsumer = new CommonsHttpOAuthConsumer(mConsumerKey, mSecretKey);
		mHttpOauthprovider = new CommonsHttpOAuthProvider("https://api.twitter.com/oauth/request_token",
				 					"https://api.twitter.com/oauth/access_token",
				 					"https://api.twitter.com/oauth/authorize");
		mHttpOauthprovider.setOAuth10a(true);
		mAccessToken	= mSession.getAccessToken();
 
		configureToken();
	}
 
	public void setListener(TwDialogListener listener) {
		mListener = listener;
	}
 
	@SuppressWarnings("deprecation")
	private void configureToken() {
		if (mAccessToken != null) {
			mTwitter.setOAuthConsumer(mConsumerKey, mSecretKey);
 
			mTwitter.setOAuthAccessToken(mAccessToken);
		}
	}
 
	public boolean hasAccessToken() {
 
		return (mAccessToken == null) ? false : true;
	}
 
	public void resetAccessToken() {
		if (mAccessToken != null) {
			mSession.resetAccessToken();
 
			mAccessToken = null;
		}
	}
 
	public String getUsername() {
		return mSession.getUsername();
	}
 
	public void updateStatus(String status) throws Exception {
		try {
			mTwitter.updateStatus(status);
		} catch (TwitterException e) {
			throw e;
		}
	}
 
	public void authorize() {
		mProgressDlg.setMessage("Initializing ...");
		mProgressDlg.show();
 
		new Thread() {
			@Override
			public void run() {
				String authUrl = "";
				int what = 1;
 
				try {
					authUrl = mHttpOauthprovider.retrieveRequestToken(mHttpOauthConsumer, CALLBACK_URL);	
 
					what = 0;
 
					Log.d(TAG, "Request token url " + authUrl);
				} catch (Exception e) {
					Log.d(TAG, "Failed to get request token");
 
					e.printStackTrace();
				}
 
				mHandler.sendMessage(mHandler.obtainMessage(what, 1, 0, authUrl));
			}
		}.start();
	}
 
	public void processToken(String callbackUrl)  {
		mProgressDlg.setMessage("Finalizing ...");
		mProgressDlg.show();
 
		final String verifier = getVerifier(callbackUrl);
 
		new Thread() {
			@Override
			public void run() {
				int what = 1;
 
				try {
					mHttpOauthprovider.retrieveAccessToken(mHttpOauthConsumer, verifier);
 
					mAccessToken = new twitter4j.auth.AccessToken(mHttpOauthConsumer.getToken(), mHttpOauthConsumer.getTokenSecret());
 
					configureToken();
 
					User user = mTwitter.verifyCredentials();
 
			        mSession.storeAccessToken(mAccessToken, user.getName());
 
			        what = 0;
				} catch (Exception e){
					Log.d(TAG, "Error getting access token");
 
					e.printStackTrace();
				}
 
				mHandler.sendMessage(mHandler.obtainMessage(what, 2, 0));
			}
		}.start();
	}
 
	private String getVerifier(String callbackUrl) {
		String verifier	 = "";
 
		try {
			callbackUrl = callbackUrl.replace("twitterapp", "http");
 
			URL url 		= new URL(callbackUrl);
			String query 	= url.getQuery();
 
			String array[]	= query.split("&");
 
			for (String parameter : array) {
	             String v[] = parameter.split("=");
 
	             if (URLDecoder.decode(v[0]).equals(oauth.signpost.OAuth.OAUTH_VERIFIER)) {
	            	 verifier = URLDecoder.decode(v[1]);
	            	 break;
	             }
	        }
		} catch (MalformedURLException e) {
			e.printStackTrace();
		}
 
		return verifier;
	}
 
	private void showLoginDialog(String url) {
		final TwDialogListener listener = new TwDialogListener() {
			@Override
			public void onComplete(String value) {
				processToken(value);
			}
 
			@Override
			public void onError(String value) {
				mListener.onError("Failed opening authorization page");
			}
		};
 
		new TwitterDialog(context, url, listener).show();
	}
 
	private Handler mHandler = new Handler() {
		@Override
		public void handleMessage(Message msg) {
			mProgressDlg.dismiss();
 
			if (msg.what == 1) {
				if (msg.arg1 == 1)
					mListener.onError("Error getting request token");
				else
					mListener.onError("Error getting access token");
			} else {
				if (msg.arg1 == 1)
					showLoginDialog((String) msg.obj);
				else
					mListener.onComplete("");
			}
		}
	};
 
	public interface TwDialogListener {
		public void onComplete(String value);		
 
		public void onError(String value);
	}
}
 

The TwitterDialog class is composed by a basic WebView which loads the URL with the authentication fields:

 
 
import android.app.Dialog;
import android.app.ProgressDialog;
 
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.Typeface;
import android.graphics.drawable.Drawable;
 
import android.os.Bundle;
import android.util.Log;
import android.content.Context;
 
import android.view.Display;
import android.view.ViewGroup;
import android.view.Window;
 
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.TextView;
 
public class TwitterDialog extends Dialog {
 
    static final float[] DIMENSIONS_LANDSCAPE = {460, 260};
    static final float[] DIMENSIONS_PORTRAIT = {280, 420};
    static final FrameLayout.LayoutParams FILL = new FrameLayout.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,
                         						ViewGroup.LayoutParams.FILL_PARENT);
    static final int MARGIN = 4;
    static final int PADDING = 2;
 
    private String mUrl;
    private TwDialogListener mListener;
    private ProgressDialog mSpinner;
    private WebView mWebView;
    private LinearLayout mContent;
    private TextView mTitle;
 
    private static final String TAG = "Twitter-WebView";
 
    public TwitterDialog(Context context, String url, TwDialogListener listener) {
        super(context);
 
        mUrl 		= url;
        mListener 	= listener;
    }
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
        mSpinner = new ProgressDialog(getContext());
 
        mSpinner.requestWindowFeature(Window.FEATURE_NO_TITLE);
        mSpinner.setMessage("Loading...");
 
        mContent = new LinearLayout(getContext());
 
        mContent.setOrientation(LinearLayout.VERTICAL);
 
        setUpTitle();
        setUpWebView();
 
        Display display 	= getWindow().getWindowManager().getDefaultDisplay();
        final float scale 	= getContext().getResources().getDisplayMetrics().density;
        float[] dimensions 	= (display.getWidth() < display.getHeight()) ? DIMENSIONS_PORTRAIT : DIMENSIONS_LANDSCAPE;
 
        addContentView(mContent, new FrameLayout.LayoutParams((int) (dimensions[0] * scale + 0.5f),
        							(int) (dimensions[1] * scale + 0.5f)));
    }
 
    private void setUpTitle() {
        requestWindowFeature(Window.FEATURE_NO_TITLE);
 
        Drawable icon = getContext().getResources().getDrawable(R.drawable.twitter_icon);
 
        mTitle = new TextView(getContext());
 
        mTitle.setText("Twitter");
        mTitle.setTextColor(Color.WHITE);
        mTitle.setTypeface(Typeface.DEFAULT_BOLD);
        mTitle.setBackgroundColor(0xFFbbd7e9);
        mTitle.setPadding(MARGIN + PADDING, MARGIN, MARGIN, MARGIN);
        mTitle.setCompoundDrawablePadding(MARGIN + PADDING);
        mTitle.setCompoundDrawablesWithIntrinsicBounds(icon, null, null, null);
 
        mContent.addView(mTitle);
    }
 
    private void setUpWebView() {
        mWebView = new WebView(getContext());
 
        mWebView.setVerticalScrollBarEnabled(false);
        mWebView.setHorizontalScrollBarEnabled(false);
        mWebView.setWebViewClient(new TwitterWebViewClient());
        mWebView.getSettings().setJavaScriptEnabled(true);
        mWebView.loadUrl(mUrl);
        mWebView.setLayoutParams(FILL);
 
        mContent.addView(mWebView);
    }
 
    private class TwitterWebViewClient extends WebViewClient {
 
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
        	Log.d(TAG, "Redirecting URL " + url);
 
        	if (url.startsWith(TwitterApp.CALLBACK_URL)) {
        		mListener.onComplete(url);
 
        		TwitterDialog.this.dismiss();
 
        		return true;
        	}  else if (url.startsWith("authorize")) {
        		return false;
        	}
 
            return true;
        }
 
        @Override
        public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
        	Log.d(TAG, "Page error: " + description);
 
            super.onReceivedError(view, errorCode, description, failingUrl);
 
            mListener.onError(description);
 
            TwitterDialog.this.dismiss();
        }
 
        @Override
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
            Log.d(TAG, "Loading URL: " + url);
            super.onPageStarted(view, url, favicon);
            mSpinner.show();
        }
 
        @Override
        public void onPageFinished(WebView view, String url) {
            super.onPageFinished(view, url);
            String title = mWebView.getTitle();
            if (title != null && title.length() > 0) {
                mTitle.setText(title);
            }
            mSpinner.dismiss();
        }
 
    }
}
 

And as we can expect, TwitterSession manages the twitter session:

 
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.Context;
 
public class TwitterSession {
	private SharedPreferences sharedPref;
	private Editor editor;
 
	private static final String TWEET_AUTH_KEY = "auth_key";
	private static final String TWEET_AUTH_SECRET_KEY = "auth_secret_key";
	private static final String TWEET_USER_NAME = "user_name";
	private static final String SHARED = "Twitter_Preferences";
 
	public TwitterSession(Context context) {
		sharedPref 	  = context.getSharedPreferences(SHARED, Context.MODE_PRIVATE);
 
		editor 		  = sharedPref.edit();
	}
 
	public void storeAccessToken(twitter4j.auth.AccessToken accessToken, String username) {
		editor.putString(TWEET_AUTH_KEY, accessToken.getToken());
		editor.putString(TWEET_AUTH_SECRET_KEY, accessToken.getTokenSecret());
		editor.putString(TWEET_USER_NAME, username);
 
		editor.commit();
	}
 
	public void resetAccessToken() {
		editor.putString(TWEET_AUTH_KEY, null);
		editor.putString(TWEET_AUTH_SECRET_KEY, null);
		editor.putString(TWEET_USER_NAME, null);
 
		editor.commit();
	}
 
	public String getUsername() {
		return sharedPref.getString(TWEET_USER_NAME, "");
	}
 
	public twitter4j.auth.AccessToken getAccessToken() {
		String token 		= sharedPref.getString(TWEET_AUTH_KEY, null);
		String tokenSecret 	= sharedPref.getString(TWEET_AUTH_SECRET_KEY, null);
 
		if (token != null && tokenSecret != null)
			return new twitter4j.auth.AccessToken(token, tokenSecret);
		else
			return null;
	}
}
 

Now let's see how this works. In this application we will need to insert our consumer and private keys in the upper variables. The rest of the code is easy to understand: we will initialize the Twitter object, and we will post!

 
 
public class ProceedActivity extends Activity {
 
	private TwitterApp mTwitter;
 
	private static final String twitter_consumer_key = "key";
	private static final String twitter_secret_key = "key";
	private String username = "";
	Dialog dialog ;
 
	 private final TwDialogListener mTwLoginDialogListener = new TwDialogListener() {
	        @Override
	        public void onComplete(String value) {
	            username    = mTwitter.getUsername();
	            username    = (username.equals("")) ? "No Name" : username;
	            Toast.makeText(getActivity(), "Connected to Twitter as " + username, Toast.LENGTH_LONG).show();
	            postToTwitter(String.valueOf("texto"));
	        }
 
	        @Override
	        public void onError(String value) {
	        	Toast.makeText(getBaseContext(), "Twitter connection failed", Toast.LENGTH_LONG).show();
	        }
	    };
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.proceed);
 
		mTwitter = new TwitterApp(this, twitter_consumer_key,twitter_secret_key);
 
		mTwitter.setListener(mTwLoginDialogListener);
 
		dialog = new Dialog(this);
		dialog.setContentView(R.layout.custom_dialog);
 
					ImageView imageTwitter = (ImageView) dialog.findViewById(R.id.imageTwitter);
 
					 imageTwitter.setOnClickListener(new OnClickListener() {
 
						@Override
						public void onClick(View v) {
							ProgressDialog dialog = ProgressDialog.show(getBaseContext(), "",
			                        "Loading. Please wait...", true);
							if (mTwitter.hasAccessToken()) {
								postToTwitter(String.valueOf("texto"));
							} else {
								mTwitter.authorize();
							}
							dialog.dismiss();
						}
 
					 });
 
	}
 
	private void postToTwitter(final String review) {
 
        new Thread() {
            @Override
            public void run() {
                int what = 0;
 
                try {
                    mTwitter.updateStatus(getResources().getString(R.string.finalTextShare)+" "+review);
                } catch (Exception e) {
                    what = 1;
                }
 
                mHandler.sendMessage(mHandler.obtainMessage(what));
            }
        }.start();
    }
 
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            String text = (msg.what == 0) ? "Posted to Twitter" : "Post to Twitter failed";
            dialog.dismiss();
            Toast.makeText(getBaseContext(), text, Toast.LENGTH_SHORT).show();
        }
    };
 
    public Activity getActivity () {
    	return this;
    }
 
}
 

Enrique López-Mañas

Let's explain this is in shortly: push is the name given to the fact that messages can be sent to the receiver, instead of being requested from the client. Although the concept might sounds easy to understand, the explanation on why the implementation is hard is a bit more complex: we can summarize it by saying that the protocol running under the modern Internet communications (TCP/IP) was not designed for Push technologies. For more information on this topic, we recommend to read the following article.

So there are three general solutions widely accepted to implement our own Push notifications:

• Google C2DM: recently released by Google,
• Poll: although it is not a real push request, the effect looks the same: we periodically poll the server looking for new data. The more often we poll the closer we get to the real-time push. But obviously, it will never be on real-time. Plus the battery will die very quickly
• Persistent TCP/IP connection: the device initiates a long-lived mostly idle TCP/IP connection by playing with the feature of "keep-alive" (sending occasionally messages to the devices). Whenever something new is on the server, the phone initiates a fully TCP connection to acquire the new data. This is the underlying technology for Google C2DM, but you might want to have full control on the entire process until C2DM provides a reliable service.

• Is able to communicate with the client.
• Will fire HTTP requests to the C2DM server.
• Handle requests algorithm (for instance, we could design it for performing an exponential back off).
• Storages the authentication tokens. They are need to handle applications with a little bit of complexity

 

As stated before, is easy to set up all the parts, but we might spend more time thinking about the third party server implementation. And that's the sugar of this article.

 

According to the source site of C2DM, the implementation of the Android is quite trivial. We first need to declare in our Manifest the required permissions for the application, which are com.google.android.c2dm.permission.RECEIVE, com.example.myapp.permission.C2D_MESSAGE and of course android.permission.INTERNET.  We also need to declare our receivers. For further information, check out the official link.

The next step is to register on our application, what can be done with the following code. Typically, we will add it into an onCreate method, or when the application needs to prepare itself for the push.

 

Intent registrationIntent = new Intent("com.google.android.c2dm.intent.REGISTER");
registrationIntent.putExtra("app", PendingIntent.getBroadcast(this, 0, new Intent(), 0)); // boilerplate
registrationIntent.putExtra("sender", emailOfSender);
startService(registrationIntent);

 
Unregistering is also trivial (again, we might want to add this into the onDestroy event):
 

 
Intent unregIntent = new Intent("com.google.android.c2dm.intent.UNREGISTER");
unregIntent.putExtra("app", PendingIntent.getBroadcast(this, 0, new Intent(), 0));
startService(unregIntent);

 
The basic part for handling the message needs a bit more of explanation. When the method onReceive of our BroadcastReceiver is triggered, we might need to check if we are dealing with the registration or if we are just receiving a push notification. We provide the code for the first case. For the second one, we might need to create our own method based on our design. We will be able to receive a message through the Intent. And that's the part we need to handle on the server side.
 

public void onReceive(Context context, Intent intent) {
   if (intent.getAction().equals("com.google.android.c2dm.intent.REGISTRATION")) {
      handleRegistration(context, intent);
   } else if (intent.getAction().equals("com.google.android.c2dm.intent.RECEIVE")) {
      handleMessage(context, intent);
   }
}
 
private void handleRegistration(Context context, Intent intent) {
   String registration = intent.getStringExtra("registration_id");
   if (intent.getStringExtra("error") != null) {
      // Registration failed, should try again later.
   } else if (intent.getStringExtra("unregistered") != null) {
      // unregistration done, new messages from the authorized sender will be rejected
   } else if (registration != null) {
      // Send the registration ID to the 3rd party site that is sending the messages.
      // This should be done in a separate thread.
      // When done, remember that all registration is done.
   }
}
 

 

So this is the core of the server application. This method needs to receive an auth code, and the device registration ID. The device registration ID will be provided when our phone is registered in the previous step. The authcode is the authentication through a Google account. For instance, we could create a dummy account, and send it along with the push notification:

 

googleAuthenticate("mydummyaccount@gmail.com","mydummypassword")

 

Afterwards, we can send a message type and the content itself. This allows us to have more flexibility in our notifications. For instance, we might provide a message type which corresponds with an error, and on the content we can send the complete error text.
 

function sendMessageToPhone($authCode, $deviceRegistrationId, $msgType, $messageText) {
    $headers = array('Authorization: GoogleLogin auth=' . $authCode);
    $data = array(
      'registration_id' => $deviceRegistrationId,
      'collapse_key' => $msgType,
      'data.message' => $messageText //TODO Add more params with just simple data instead
   );
 
   $ch = curl_init();
 
   curl_setopt($ch, CURLOPT_URL, "https://android.apis.google.com/c2dm/send");
   if ($headers)
      curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
      curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
      curl_setopt($ch, CURLOPT_POST, true);
      curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
      curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
 
      $response = curl_exec($ch);
 
      curl_close($ch);
 
      return $response;
   }
 
function googleAuthenticate($username, $password, $source="Company-AppName-Version", $service="ac2dm") {
 
   if( isset($_SESSION['google_auth_id']) && $_SESSION['google_auth_id'] != null) {
   return $_SESSION['google_auth_id'];
}
 
// get an authorization token
$ch = curl_init();
if(!ch){
   return false;
}
 
curl_setopt($ch, CURLOPT_URL, "https://www.google.com/accounts/ClientLogin");
$post_fields = "accountType=" . urlencode('HOSTED_OR_GOOGLE')
 
. "&Email=" . urlencode($username)
. "&Passwd=" . urlencode($password)
. "&source=" . urlencode($source)
. "&service=" . urlencode($service);
curl_setopt($ch, CURLOPT_HEADER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post_fields);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_FRESH_CONNECT, true);
curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
 
// for debugging the request
//curl_setopt($ch, CURLINFO_HEADER_OUT, true); // for debugging the request
 
$response = curl_exec($ch);
 
//var_dump(curl_getinfo($ch)); //for debugging the request
//var_dump($response);
 
//var_dump(curl_getinfo($ch)); //for debugging the request
//var_dump($response);
 
curl_close($ch);
if (strpos($response, '200 OK') === false) {
   return false;
}
 
// find the auth code
preg_match("/(Auth=)([\w|-]+)/", $response, $matches);
 
if (!$matches[2]) {
   return false;
}
$_SESSION['google_auth_id'] = $matches[2];
 
return $matches[2];
}

 

I hope you enjoyed the tutorial. For any further questions or inquiries, you can drop me a line into my personal email.

 

Enrique López-Mañas

]]> http://www.neo-tech.es/wp/?feed=rss2&p=77 0 http://www.neo-tech.es/wp/?p=71 http://www.neo-tech.es/wp/?p=71#comments Mon, 26 Dec 2011 17:48:33 +0000 admin http://www.neo-tech.es/wp/?p=71 Since I have been working in Barcelona, I got so much in touch with Android and mobile developers than in Germany, since my work there was a little bit more theoretical rather than applied.

Although I don't use on a regular basis Google Translate or any engine to translate my applications (this is a problem of quality vs. quantity, where I bet quality should prevail), I realized that many developers of successful applications are using Google Translate to generate new string files of their projects. And it is, in fact, much more widespread of what I thought. When I have been talking with those developers, they confess after one or two beers that they use web powered engines (i.e., Google Translate) and they usually don't perform a pair check or a professional review of their generated tokens. Without judging this behavior, I was interested in the procedure, and the first question to arise was: have you automatized the process? The most recurrent answer was a "No", while they began to stare at the floor.

I thought it could be interesting for some projects, so I thought I could expand the translation tool I published a few months ago. Why couldn't we just perform the translation systematically? And that's why I'm presenting the second version of the tool.

The Google Translate API is not free, and since I don't want to offer my API key and see a huge bill at the end of the month in my bank account, I'm offering two different versions of the tool: the first version allows you to insert your own key, and perform the translation. And if you don't want to deal with the registration and Google Checkout, you can get a paid version which uses my own API key for only 5$. So if you think this tool can be helpful for you, those 5$ will make you save a lot of time and I will get a few extra beers and some support to develop projects on my free time. As shown on the following screen, you just need to type your API key on the following edit text.

There are still some upcoming tasks to be performed, but this can be considered as a working alpha version.

This tool will not be released as GPL software as the previous one. However, if you need the source code for any purpose you always can send me an email in order to convince me.

The free version can be download from here (version 2.0). If you want the paid version, feel free to drop me a line or contact me via Twitter or Facebook

]]> http://www.neo-tech.es/wp/?feed=rss2&p=71 0 http://www.neo-tech.es/wp/?p=67 http://www.neo-tech.es/wp/?p=67#comments Fri, 18 Nov 2011 11:03:56 +0000 admin http://www.neo-tech.es/wp/?p=67 Last Wednesday we inaugurated the IdkLabs at our office. The underlying philosophy is to create a space of coworking and to put in practice our own ideas and personal projects. It is a real injection of fresh air to work in more creative topics, and to forget a bit of the mechanic, less pleasant development. Plus the result of working in a funny, fresh environment with talented people can only result in good ideas' conceptions.

 

There are several proposed models of BrainStorming, and we decided to experiment with a structured (also called circular) variation of BrainStorming: during all day long each person with a proposal should send it anonymously to the BrainStorming Master. The proposals could not be longer than a couple of sentences.

 

At the beginning of the BrainStorming, all the proposals were distributed among the participants. From that point on, there wasn't any limitation for the number of proposals per person, and they were just voluntary, we could have more or less proposals than people. In this case we had 7 proposals and 18 people. So we distributed each proposal trying to be as symmetrical as possible (i.e., keeping the same distance between each person with a proposal).

 

 

In one minute time, each person reads the proposal and jotts down in the paper any idea, and after the minute they should give the piece of paper to the person sitting to their right. Eventually, they would receive another piece of paper from their left side, and the process continues until all the people have written in all the pieces of paper. Although this might sound like a little game, it really helped us to gain some feedback and new ideas, and to get into a funny atmosphere. When everything was over, the owner of each proposal had up to 5 minutes to explain it, and to convince the unconvinced or the people with no proposal that they should join their project. By this time, it is likely that the group will have extensively elaborated on each idea.

 

 

What came next was a free space of creation. We talked about the projects, about ideas to expand them or about any topic we wanted, but everyone kept the discussed projects in mind. Some of us moved our computers into the meeting room, so we could work and talk together. Although we didn't have a lot of time to code or begin with the projects, we began to draft and collect our thoughts. A few warriors stayed until almost 23:00, so we can consider this event as being widely accepted in its first edition.

 

We aim to keep this meeting bi-weekly, although considering the scope of the proposals it might change to weekly. More reports to come!

 

Oh yes, you might be wondering what happens with the projects we began to work on. Although we didn't sign any NDA, we would like to talk about them in future posts, so remember to add the website to Google Reader or your favourite RSS reader

 

]]> http://www.neo-tech.es/wp/?feed=rss2&p=67 0 http://www.neo-tech.es/wp/?p=53 http://www.neo-tech.es/wp/?p=53#comments Sun, 09 Oct 2011 20:04:36 +0000 admin http://www.neo-tech.es/wp/?p=53 I recently moved to Barcelona to start working in here. Although I'm not working in any computer-vision based project, I still keep a high interest in this field, trying to conduct as many personal projects as possible. My work team is highly motivated and full of professionals, and we all keep our personal projects besides our work.

Recently I met Fegabe in Barcelona, who's a member of the GTUG Barcelona core team and an Android Developer. We decided to start together a Sudoku Solver for Android. Although there are already many of them published in the Market, we just wanted to do it for fun and to get a bit deeper into computer vision and pattern recognition. There is an OpenCV port for Android, but we decided to keep our implementation pure Java.

The following steps are applied in order to capture, detect and solve the Sudoku:

-The user must take a picture of the Sudoku using the camera of the device.

-After the picture is taken, a Threshold is applied to the image, so we can get a black and white version. Of course, there is some preprocessing involved. Things like smoothing out noise, some morphological operations, etc.

-When the picture has been taken, we apply a blob detection in order to detect the biggest segment of the image. We work under the assumption that this segment will be the outer line of the Sudoku table.

-Afterwards, we can use the Hough transform to get lines in the image. It returns lines in mathematical terms. So after this step, we’ll know exactly where a lines lies… and not just the pixels where it lies.

-When the lines has been detected, it will be easier to locate each individual cell. The number inside will be recognized using a neural network.

-The last step is the easiest: we just solve the sudoku by using any of all the known algorithms

The Sudoku Solver is still to be finished, but the cvBlob library is working fine, so I decided to publish it. The implementation is based on Dr. Andrew Greensted suggestion for Blob Detection.

I shared the project with a GPL license in Google Code. All the technical information can be found there, besides the source code and a binary file for Android. If you wanna try out, I would highly appreciate any feedback

 

 

]]> http://www.neo-tech.es/wp/?feed=rss2&p=53 0 http://www.neo-tech.es/wp/?p=51 http://www.neo-tech.es/wp/?p=51#comments Sat, 30 Jul 2011 10:54:15 +0000 admin http://www.neo-tech.es/wp/?p=51 Recently, I publish one application into the Android Market that tries to predict when Spain will default. The application uses the data provided by my colleague Juan Carlos Barba from his server. There are basically a set of levels pointing out the seriousness of the Spanish level of CDS and Spread of the debt. The model establishes 5 different levels of alert (or how he called them, DefCon). My implementation customized the data to visualize into the Android Platform.

Firstly, I needed to access his database into the server, which was a slow task due to the nature of the server (a personal computer with a normal DSL connection). My idea was to rely this task into something that could avoid overloading the server, and then I thought about everything that happens now with all the client / server application. Why not using a PHP file to generate JSON with the information I needed?

Since I do not have access to Juan Carlos' server, I decided to do it on my own server. I created some PHP files that query the server, and give me the information in JSON format

 
<?php
mysql_connect("jcbcarc.dyndns.org","user","password");
mysql_select_db("economia");
 
$q=mysql_query("SELECT * , DATE(FechayHora) AS fecha FROM economia.spreads GROUP BY fecha ORDER BY fecha;");
while($e=mysql_fetch_assoc($q))
        $output[]=$e;
 
print(json_encode($output));
 
mysql_close();
?>
 

Now the data has to be requested and handled from the Android side:

 
private void initPHP() {
		//http post
		 String result = "";
		  InputStream is = null ;
		 try{
			 DefaultHttpClient httpclient = new DefaultHttpClient();
		         HttpPost httppost = new HttpPost("http://www.neo-tech.es/defcon/cds.php5");
		         HttpResponse response = httpclient.execute(httppost);
		         HttpEntity entity = response.getEntity();
		         is = entity.getContent();
		 } catch(Exception e) {
		         Log.e("log_tag", "Error in http connection "+e.toString());
		 }
		 //convert response to string
		 try{
		         BufferedReader reader = new BufferedReader(new InputStreamReader(is,"iso-8859-1"),8);
		         StringBuilder sb = new StringBuilder();
		         String line = null;
		         while ((line = reader.readLine()) != null) {
		                 sb.append(line + "\n");
		         }
		         is.close();
 
		         result=sb.toString();
		 }catch(Exception e){
		         Log.e("log_tag", "Error converting result "+e.toString());
		 }
 
		 //parse json data
		 try{
		         JSONArray jArray = new JSONArray(result);
		         int lastDay = 0;
		         for(int i=0;i<jArray.length();i++){
		        	 JSONObject json_data = jArray.getJSONObject(i);
		        	 DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		        	 Date day = null;
		        	 try {
		        		 day = df.parse(json_data.getString("FechayHora"));
		        	 } catch (ParseException e) {
		        		 e.printStackTrace();
		        	 }
		            if (i == 0)
		            	lastDay = day.getDay();
		            if (day.getDay() != lastDay) {
		            	mEntity.getCdsData().add(new CDS(json_data.getInt("Secuencial"),day,json_data.getString("Pais"),json_data.getDouble("CDS")));
		            	lastDay = day.getDay();
		            }
		         }
		 } catch(JSONException e){
		         Log.e("log_tag", "Error parsing data "+e.toString());
		 }
	 }
 

The code can be improved to handle authentication, HTTPS, or do more complex work in general. In a project at work we used authentication based on a pair of generated keys, but a simple method based on a known keyword is enough.

]]> http://www.neo-tech.es/wp/?feed=rss2&p=51 0 http://www.neo-tech.es/wp/?p=50 http://www.neo-tech.es/wp/?p=50#comments Fri, 29 Jul 2011 11:51:52 +0000 admin http://www.neo-tech.es/wp/?p=50

As an Android developer, I have been concerned during the last months about why the Android Market seems to be less profitable than the App Store. I have access to some statistics of my application's ports to iPhone/iPad: while the free applications don't seem to be affected, the paid applications have a huge gap with their iOS counterpart: they are downloaded up to 50 times more. I only can feel that I chose the wrong mobile platform to develop for. But why is this happening?

There are a bunch of well known differences between the nature of iOS and Android applications, but not all of them affect the sells. According to the report of Gartner (April 2011), 38.5% of the smartphone market belongs to Android, while 19.4% belongs to iPhone. It is almost the double for Android, and the growth has been astonishing: from an estimated 3.9% in 2009, it has rapidly overtaken all of their competitors

But if we look on the statistics, Apple's iPhone App Store is still larger in size than the Android Market. It houses more than 350,000 applications and games, while it was reported in Business Insider in March 2011, that the Android Market has hit the 250,000+ mark. This obviously has as well a dark side: with many competing applications, is harder to sell our own application. Android does not have (yet) as many applications as the iPhone store, but it lacks of a Desktop client (iTunes) and it is much less user friendly (a field where Apple always wins).

So there we go: Android has sold more phones, and iOS has published more applications. One of the first thoughts is that the developers are choosing iOS for a misterious reason. I might point out here one of the main problems with Android: the fragmentation. Whereas Google provides the operative system, the different manufacturers provide the hardware. This leads into a huge uncontrolled mess: different phones may support (or not) different features (i.e., camera, giroscope, etc), which is a problem for developers.

In order to ensure a minimum of compatibility between many devices, Google Android has the Compatibility Program, an automated control mechanism that determines which device is minimally compatible with Android.

The devices that pass the program can use the official logo of Android, and what is truly important, they can integrate the application that gives access to Android Market, Android application repository.

Another reason could be the politics of payment and refund. Payments on the iPhone App Store are handled via your iTunes account which is linked directly to your credit card, whereas Android uses Google Checkout, a paypal clone of Google. Many people have an iTunes account since a few years, but Google Checkout is still relatively unknown (I didn't have an account until I need it to get my revenues from the Android Market!).

Also one major difference between the Android Market and the iPhone App Store is refunds. With Android, you can test an application for 15 minutes and uninstall it in order to obtain a refund. However, this is not allowed in iPhone App Store. This results in greater sales in iPhone Store, enabling more revenue for the developers.

So what exactly is going wrong in the Android Market? In my opinion there are several reasons, first and most important of these is that the Android Market, even though its recent renovation earlier this year, it remains still below the design level of the App Store. And since we download through the device, we really need a good design and features to facilitate the user purchase.

There are also rumours that Google promotes free and ad-supported applications instead of paid applications, that Android users belong to an economically lower profile than the iOS users, or that they did not have time to do things better. I want to believe that the main reason is a ponderate mix of all the aforementioned reasons, with a special weight of the last one: Android has been a special challenge for a company that never worked in mobility, and they still need a little bit of time to improve everything. They have already begin to improve the Android Market and they are doing a huge effort to solve the fragmentation problem. Amazon Store will also be relevant next year.

I think it takes a little but longer, but hopefully Android will eventually get off and will be as profitable for developers as the App Store it is today.

Some other links:

• mobiThink report
• TechCrunch analysis

]]> http://www.neo-tech.es/wp/?feed=rss2&p=50 0