If size does not matter for the app, the "fat" version is the carefree option to be used for execution on simulator and real devices.

/**
 * Importing SpringMobile
 */
import de.spring.mobile.SpringMobile;

/**
 * Generating SpringMobile entity with site id and 
 * application name
 */
SpringMobile spring = new SpringMobile("<site>", "Application Name", getApplicationContext());

/**
 * Sending the start of the application to the measurement system
 */
Map<String, Object> map = new HashMap<String, Object>();
map.put(SpringMobile.VAR_ACTION, SpringMobile.APP_STARTED);
spring.commit(map);

/*
 * Sending the action spring.BACKGROUND
 */
Map<String, Object> map = new HashMap<String, Object>();
map.put(SpringMobile.VAR_ACTION, SpringMobile.APP_BACKGROUND);
spring.commit(map);

Example Activity:
import android.app.Activity;
import android.os.Bundle;

public class TestActivity extends Activity {
private SpringMobileHelper springHelper;

@Override
public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); 
springHelper = SpringMobileHelper.getInstance(getApplicationContext()); }

@Override
protected void onStart() { super.onStart(); springHelper.start(); }

@Override
protected void onResume() { super.onResume(); springHelper.resume(); }

@Override
protected void onPause() { super.onPause(); springHelper.pause(); }

@Override
protected void onDestroy() { super.onDestroy(); springHelper.destroy(); }

}
Helper Class:
import java.lang.Thread.State;
import java.util.HashMap;
import java.util.Map;

import android.content.Context;
import de.spring.mobile.SpringMobile;

/**

    This class will help to manage more than one Activity. The Class holds the SpringMobile object and managed the events to it.
    */
    public class SpringMobileHelper {
    private static SpringMobileHelper singelton = null;

private SpringMobile spring = null;

private boolean isStarted = false;
private int foregroundCounter = 0;
private final Thread sendBackground = new Thread() {
@Override
public void run() {
super.run();

while(true) {
synchronized(sendBackground) {
try { wait(); } catch (InterruptedException e) { continue; }

try { sleep(1000); Map<String, Object> map = new HashMap<String, Object>(); 
map.put(SpringMobile.VAR_ACTION, SpringMobile.APP_BACKGROUND); spring.commit(map); } catch (InterruptedException e) {}

}
}
}
};
{sendBackground.start();}

private SpringMobileHelper() {
}

/**
*

    @param the context
    @return SpringMobileHelper
    */
    public static SpringMobileHelper getInstance(Context context)
    Unknown macro: { if(singelton == null) { singelton = new SpringMobileHelper();
    singelton.spring = new SpringMobile("app", "MoreActivities", context); } return singelton; }

/**

    call by start of activity
    */
    public staticvoid SpringMobileHelper getInstance(Context contextstart()
    Unknown macro: { if(singelton == null!isStarted) { singeltonisStarted = new SpringMobileHelper()true; Map<String, Object> map  singelton.spring = new SpringMobile("app"HashMap<String, "MoreActivities", contextObject>(); spring.commit(map); } return singelton; }

/**

    call by startresume of activity
    */
    public void startresume()
    Unknown macro: { foregroundCounter++; if(sendBackground != null && sendBackground.getState(!isStarted) != State.WAITING) { isStarted = true; sendBackground.interrupt();
    } else { Map<String, Object> map = new HashMap<String, Object>( HashMap<String, Object>(); map.put(SpringMobile.VAR_ACTION, SpringMobile.APP_FOREGROUND); spring.commit(map); }
    }

    /**
    * call by resumepause of activity
    */
    public void resumepause() {
    foregroundCounter--;
Unknown macro: { foregroundCounter++; if(sendBackground != null && sendBackground.getState() != State.WAITING) { sendBackground.interrupt(); }    }
else
{ Map<String, Object> map = new HashMap<String, Object>(); map.put(SpringMobile.VAR_ACTION, SpringMobile.APP_FOREGROUND); spring.commit(map synchronized(sendBackground) { sendBackground.notify(); }
    }

  

/**

   * call by pausedestroy of activity
    */
    public void pausedestroy() {
    foregroundCounter--;
 if(foregroundCounter == 0) {
  if(sendBackground != nulltry &&{ sendBackground.getStatejoin(1000) != State.WAITING) { sendBackground.interrupt(); } ; Map<String, Object> map = new HashMap<String, Object>();
    map.put(SpringMobile.VAR_ACTION, SpringMobile.APP_CLOSED); spring.commit(map); } catch (InterruptedException e) {}
    }
    }

synchronized(sendBackground) { sendBackground.notify(); }
    }}

/**
 * Example AC
 */
import de.spring.mobile.SpringMobile;

/**
 * Generating SpringMobile entity call by destroy of activity
  with site id and application name
 */
SpringMobile spring = new  public void destroy() {
    if(foregroundCounter == 0) {
    try { sendBackground.join(1000);SpringMobile("<site>", "Application Name", getApplicationContext());

/**
 * Sending AC to the measurement system
 */
Map<String, Object> map = new HashMap<String, Object>();
    mapmap.put(SpringMobile.VAR_ACTION, SpringMobile.APP_CLOSED"ac", "Mainpage");
spring.commit(map);
} catch (InterruptedException e) {}
    }
    }

}

<uses-permission android:name="android.permission.READ_PHONE_STATE">
</uses-permission>
<uses-permission android:name="android.permission.INTERNET">
</uses-permission>

<meta-data android:name="com.google.android.gms.version" android:value="@integer/google_play_services_version" />

The setting of the permission through the user is not mandatory, but highly recommended.

If the permission READ_PHONE_STATE is set, the device ID and the Android ID are used.

If the permission is not set, only the Android ID is used.

The last one item above is for the registration of google-play-services, which is precondition for retrieving Google Advertising ID.

Two aspects are crucial:
The Android ID is only recognized if the user disposes of a Google account. (This should be the case for all users of the apps, because it is not possible to access the Android Market without a Google account.)

There is a bug in the Android version 2.2, which only occurs in connection with certain providers, where for all affected devices the same Android ID will be delivered. For the study, this would mean that the user identification would become much more difficult.

SpringMobile spring = new ("app","TestApp",getApplicationContext());
spring.setTimeout(30); // in seconds

Note: Starting from Android 3.0

Since Android 3.0 network accesses are not allowed from the main thread anymore. Thus, the Spring.commit () method is achieved in a background thread.

For this reason, please keep the initialization and usage of Spring lib in your main UI thread, Spring lib will not block your GUI display. Otherwise background thread conflicts might pop up.