New Features:

• Set custom targets to shoot at!
• Face Detection detects faces in your custom targets to enable Headshot mode! (paid version only)
• 360 Flyby mode
• Gun Biography & History
• Built-in music tracks
• Multiple challenging targets
• WVGA854 and WVGA800 Screen size support!
• Unlimited Ammo (John Woo) Mode

The latest version of GunZ 1911 MEU is now in the market as both a Free and Paid version!  For those of you who haven’t seen this new game for Android, here are some screenshots.

Stay tuned for the next gun added to the lineup!

The iPlacemarks are geared towards the users specific tastes,  and in this tutorial we will be using the ‘Coffee Shop iPlacemark’ for Android 1.5+. If you do not have a Foursquare account or the app you can get both for free at Foursquare.com!

Upon opening the app, it will attempt to determine your location via GPS satellites.  If you don’t have a GPS signal just be patient it usually only takes a few seconds.

In this new version of iPlacemarks you will now see your location selected on the map as well as secondary locations in your are which are not highlighted as in the picture above.

If you see the foursquare icon in the upper left corner is highlighted, that means Foursquare knows about this location and you will be ready to checkin for points when you get there!  You can click the icon to get more information about the location such as the phone number and various specials.

Now if this location just isn’t for you, go ahead and close the information panel with the close button or by pressing the back button on your phone.  Now you can tap any of the nearby locations on the map and route there instead!

Now that you have the location you want, you can always check the directions panel to check your exact directions.

When you arrive at your location, you can check right in with foursquare by using the checkin button on the information panel.

If you have never logged into the app before, you will need to do this once.  Your foursquare information is never sent anywhere but the Foursquare servers and is stored privately to protect your privacy.

After checking in you will see any rewards that you have earned as well as the current mayor and any specials that you might be interested in.

iPlacemarks also offers you several options for configuring your navigation experience.  Press the ‘menu’ button on your phone (or the small button with 3 lines). This will pull up the menu to give you some more options.

The ‘My Location’ button will pan the map to your current location in case you were exploring around the map.  The directions button takes you to the same directions panel as the lower-right corner shortcut on the map.  Press settings to bring up the user preferences.

Minimum distance settings: this allows you set a minimum distance for your nearest location.  This is helpful if you want to find new spots outside your normal range.

The auto-show information option allows you to have iPlacemark automatically show you the Foursquare pop-up.

And that’s it! We’ve tried to go into deep details here but all you really need to remember is to tap the icon! If you have any other questions or comments, feel free to contact us as contact at androidteam.info

ItemizedOverlay

The ItemizedOverlay type is great for placing pins on a map that move with the map when the user scrolls.  By overriding the very convenient onTap() method of this class we can detect when a user clicks any on any one of a number of overlays.

Overlay

The ‘Overlay’ type allows a static floating overlay to be drawn over the map.  When drawing an overlay this way however, you will see that there is only one onTap() method  which is slightly different from the one available in ItemizedOverlay and this mechanism will not be aware of the size or bounds of the items you have drawn or places.

This presents a problem because now when the user clicks anywhere on the screen, this overlays onTap method is called!

So what can we do? I’ve created an easy solution that you can use to build an Overlay interface so that an easy change in your existing Overlays will allow you to make them easily ‘clickable’.

First,create your interface which accepts a MapView object in the constructor.  I have also added custom offset parameters for easy re-use of the interface while placing buttons in different locations.

public class MyFloatingOverlay extends Overlay {

private Context ctx;
private final Bitmap image;
private Venue venue;
private Point offset = new Point();
private MapView cMap;
protected String Tag = “default”;

private int mapViewWidth = 0;
private int mapViewHeight = 0;
private int xCenterOffset = 0;
private int yCenterOffset = 0;

public MyFloatingOverlay(MapView m,Context c, int resId, int offsetX, int offsetY)
{
cMap = m;
offset.x = offsetX;
offset.y = offsetY;
image = BitmapFactory.decodeResource(iPlacemark.getCtx().getResources(), resId);
ctx = c;

mapViewHeight = m.getHeight();
mapViewWidth  = m.getWidth();

xCenterOffset = mapViewWidth/2;
yCenterOffset = mapViewHeight/2;
}

You can see that we also store a few variables as they are reused also in the draw method shown below.

Now for the basic draw method which places your image:

@Override
public void draw(Canvas canvas, MapView mapView, boolean shadow) {

Paint pathPaint = new Paint();
pathPaint.setAntiAlias(true);
pathPaint.setStyle(Paint.Style.STROKE);

canvas.drawBitmap(image, xCenterOffset + offset.x, yCenterOffset + offset.y, pathPaint);
}

This method simply draws the bitmap decoded from the resource id given in the constructor, such as ‘R.drawable.mybutton1′.

And now the important part of this class which you will re-use in all child classes.  This helper method will tell you, given the location information supplied by onTap(), if it was your particular overlays image that was clicked on:

protected boolean tapOnMe(GeoPoint p, MapView m){

final Projection pr = m.getProjection();
int minX = xCenterOffset + offset.x;
int minY = yCenterOffset + offset.y;
int maxX = minX + image.getWidth();
int maxY = minY + image.getHeight();

Point pt = pr.toPixels(p, null);

if(pt.x >= minX && pt.y >= minY &&
pt.x <= maxX && pt.y <= maxY){
return true;
}

return false;
}

This method projects the absolute boundaries presented by your drawable and returns true if the users click fell inside this area.

A basic use of this class from an overridden onTap() method should look like this:

public boolean onTap(GeoPoint p, MapView m) {

if(tapOnMe(p, m)){
iPlacemark.log(“["+Tag+"] floating overlay tapped! “);
return true;
}

return false;
//return super.onTap(p, mapView);
}

You might also override this as a standard class like so:

MyFloatingOverlay dOverlay2 = new MyFloatingOverlay(mapView1,this,R.drawable.overlay_checkin,5,95){
@Override
public boolean onTap(GeoPoint p, MapView mapView) {
if(tapOnMe(p, mapView)){
log(“checkin button was clicked!”);
return true;
}
return false;
}
};

This is a quick solution that is great for buttons and other objects which are rectangular or round, stay tuned for an updated solution to handle odd-shaped images and multiple overlays managed by the same class!

The Chinese iPad clone: aPad

Source:

http://chinagrabber.com/china-ipad-apad-tablet-pc—android-1-5-mini-notebook—apad-m008.aspx

This tablet has some great features and really exposes some of the great possiblities for android OS, while keeping the cost low enough for anyone to afford!

We’ll go over a few of the best things about the tablet here, with some images, enjoy!

Screen

There’s no denying it, this screen is slick.  With a large WVGA800 screen, at 4.8 inches, this screen looks better than any phone we’ve seen, and better than most laptops!  The touch support is very decent, and came at just about the right level of sensitivity to prevent akward feedback while handling this device which is mostly screen.

We think this is the perfect device for the car, hotel, or office.  And even when at home, you can attach the Archos 5 to a TV for flawless playback and streaming of your home movies.

Peripherals & Connectivity

The Archos is meant to be affordable, so right out of the box you aren’t going to see too many useless bells & whistles. With built-in bluetooth and wireless, and a usb cable,  tethering to a phone  or PC is a breeze.

While there are ample accessories available, from windshield mounts for easy GPS driving directions, extended life batteries, to special carrying cases, we think many users will appreciate the fact that they aren’t paying for these extras unless they choose to.

You can even get a DVR accessory for recording TV shows, and a helmet camera for extreme sports, filming tutorials, or just just for fun!

In the box you will find a usb cable for charging and connection to PC, as well as a small vertical stand and a lint-free Archos cloth.  A dock is available that upgrades the device with composite and s-video out, and a full-size usb port for other devices. We thought the dock could have been designed a bit better since it doesn’t stand upright on it’s own, but other than this it’s very convenient.

A UPNP media server makes streaming movies and music very easy, and we actually tested this using windows 7 and the PS3 Media Server.  While streaming a large divx file, playback was very smooth as was scrubbing through the video timeline and adjusting other settings.

When in ‘TV Mode’, the phone screen basically turns into a large touchpad, and a mouse cursor is displayed on the screen for easy manipulation of  the user interface and we were glad to see that videos were played in the proper full-size aspect ratio on our LCD TV.

With the available connectivity options and open source nature of Android which allows for all sorts of 3rd party programs, this is one of the best connected devices out there without a satellite/3g internet connection.  For the price, it’s pretty amazing.

Gaming

The Archos is definitely ready for gaming.  With dual processors clocking in at over 1ghz total power, and support for ADOBE FLASH games, the Archos already has a library of great free games on the internet which can be downloaded and played right on the phone.

Combine this with the emulators available for android (SNES, NES, Genesis, Gameboy Advance, NEO-GEO, etc.), and the great tv-out support, this device  is a classic gamers dream.

The Archos game store, still in the early stages, also allows users to purchase commercial games for the device.

Applications

The Archos does not come with the google market, however, it does have it’s own market software where developers can upload and share apps, or sell an application as well. You will find most of the google released apps here, and in the future we think many other apps will show up here as well.

The device comes with an application called ‘nDrive’ which is a gps driving application with very nicely spoken driving directions.  We found this application very easy to use and had no problem having it find some local restaurants.

With a car mount available for $25, this could be the perfect device for anyone needing direction assistance while driving!

Price

Starting at $249.99, this is an internet device that many can afford. Not only can it replace a laptop for some quick web-browsing, but can easily take the role of expensive vehicle GPS systems, handheld media/audio players, DVR (with accessory), video camera (with accessory),  handheld gaming devices and even remote controls. Soon you can even make Skype calls on the device using the native android client.  A DVR accessory can turn your archos in a full-fledged DVR, replacing costly monthly fees for hardware from your cable/satellite providers.

We think this is an amazing deal and hope that other electronics manufacturers take note of what can be done with an open-source linux-based operating system such as Android.

Now since the user can have many apps open at once, android has a specific lifecycle for every application and non-focused applications can be paused, or even destroyed, if the OS deems it necessary.

Now what does this mean for the developer? It means simply relying on ‘onResume’ to bring your application back to life, is not sufficient. Some heavy programs or process might become a foreground application, and your app, while paused, may get completely destroyed, only to come back to re-initialization!

So without going into complicated workarounds, just remember to be ready to restore the state of your application (via one of several forms of persistent configuration storage) from both onCreate and onResume methods. Good luck Android devs!

reference: http://developer.android.com/reference/android/app/Activity.html

Game Development

Game development on iPhone has been a big deal for some time now, and the sdk provides a great level of access to an even greater GPU.  With 3rd party game development libraries http://oolongengine.com/ development can become a breeze, and this is big step forward from where android sdk and ndk are currently at.

Game development on android gives the developer direct access to OpenGL components and the android NDK allows the execution of C libraries which are much faster than the java code most apps are written in.  With new android devices being paired with beefy hardware, this is going to allow for some amazing games to be produced!  The downside? The difficulty level is very high to create a 3D opengl game.

As of right now, iPhone is the winner in this category.

UI Development

The Android sdk uses xml based layouts for easy abstraction of a view layer in your applications, and a goo dnumber of builtin controls and ‘intents’ that you can use to improve the look and feel of your application.  3rd party android-based SDK’s take this even further, styling some application controls to a consistent theme. The number of controls available will really have any web developer feeling at home!

The well thought out design layer in the Android SDK I think gives this category to android hands down.

Speed

When you talk about comparing Java to Objective C, Objective C is clearly the winner but speed is not everything.  Objective-C on iPhone OS has no garbage collector and will not be as fast as pure C code.  Remember on the android NDK you can run C code directly on the underlying linux system.

Networking

When it comes to mobile, TCP/IP just doesnt cut it. With the constant instability of a mobile internet connection due to movement on the ground, the tcp/ip protocol doesn’t provide any way to re-establish connections that have been ‘clipped’ by this temporary outage.

Introducing Delay-Tolerant-Networking (DTN). This state-of-the-art protocol being created by Vint Cerf who also co-invented tcp/ip in the 70s, and allows devices to disconnect and reconnect to the network without ever actually ‘loosing’ a connection.  This is a big way off from just ‘resuming’ a file download, although the concept is similar, as it is taking place at a very low level in the operating system!

Why is this so exciting? The protocol has already been added to Google’s Android open source mobile stack as an application platform – i.e it sits on top of the OS. Take that apple.

http://www.theregister.co.uk/2009/11/05/vint_cerf_on_mobile/

/me tips his hat to Android.

Market

I’m not going to go into details here, but needless to say, releasing an application on the google market is much like creating a website, there is not much of a pre-approval process. This will of course change on the Lenovo, Motorola, SKT, and HUAWEI markets,  but the Goog’s will likely remain the same. Releasing applications on the iPhone can be like driving through an IRA checkpoint.

Android market FTW.

omg giantphone

That is all.

Android SDK gives us a good bit of information about motion events, and can be configured in a way that best suits your application.  Keep in mind, that listening to these events, just like any other action will contribute to battery drain and even more so if you use a quicker polling time, beware!

First of all, do not implement SensorListener in your Activities, as this is DEPRECATED!

Ok so now that we’ve got that out of the way, lets jump right into the code!  Have you already implemented SensorListener as a solution? Dont worry this is very similar.
First off, lets declare a private variable to access the systems SensorManager.

private SensorManager sensorMgr;

Now in our onCreate, let’s get a handle to the sensor manager and register a class to handle events!

sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);

boolean accelSupported =  sensorMgr.registerListener(sensorListener,
sensorMgr.getSensorList(SensorManager.SENSOR_ACCELEROMETER).get(0),
SensorManager.SENSOR_DELAY_UI);

if (!accelSupported) {
if(!DBG_MODE)
Log.w(“onCreate”,”Accelerometer not supported!”);
// no accelerometer on this device
sensorMgr.unregisterListener(sensorListener,
sensorMgr.getSensorList(SensorManager.SENSOR_ORIENTATION).get(0));
}
else
{
if(!DBG_MODE)
Log.w(“onCreate”,”Accelerometer callback registered!”);
}

Not so bad right? And we even included support for devices without accelerometers (yes there are and will be more of these)!

I know you are already thinking… “wtf is sensorListener’ , well this is where we recieve events and it can be defined right in your activity like this:

private SensorEventListener sensorListener = new SensorEventListener() {

@Override
public void onSensorChanged(SensorEvent se) {

//we got a change in the motion sensor!
}

@Override
public void onAccuracyChanged(Sensor arg0, int arg1) {

};

And now, we’re already receiving motion events!  So what can we do with them? Well let’s try to detect a ’shake’ in the phone. Declare a few variables to store motion information in-between updates, as the motion sensor will only be polled so often. The shake threshold is not a real speed, but relative to how fast you’ve moved the phone.

private static final int SHAKE_THRESHOLD = 500;
private long lastUpdate = -1;
private float x, y, z;
private float last_x, last_y, last_z;

if (se.sensor.getType() == SensorManager.SENSOR_ACCELEROMETER) {
long curTime = System.currentTimeMillis();
// only allow one update every 100ms.
if ((curTime – lastUpdate) > 200)
{
long diffTime = (curTime – lastUpdate);
lastUpdate = curTime;

x = se.values[SensorManager.DATA_X];

float speed = Math.abs(x – last_x) / diffTime * 10000;

if (speed > SHAKE_THRESHOLD)
{

Toast.makeText(this, “shake detected w/ speed: ” + speed, Toast.LENGTH_SHORT).show();

}
last_x = x;
}

}

And with any luck, we’re shakin away at those UI interactions, how can we use this to make an awesome app? Well that’s up to you of course!

-Base64