fetching data from remote server in Android
The following example will help you to learn on fetching data from remote server in android
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import android.app.Activity;
import android.os.Bundle;
import android.widget.ImageView;
import android.widget.TextView;
public class httpsData extends Activity {
/** Called when the activity is first created. */
ImageView img;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

//calling the DownloadDataFromServer function for fetching data from remote server.
String str = DownloadDataFromServer(“http://www.schogini.in/test/”);

//display the text via TextView
TextView tv1 = (TextView) findViewById(R.id.TextView1);
tv1.setText ( str );
}

private String DownloadDataFromServer ( String URL )
{
int BUFFER_SIZE = 2000;
InputStream in = null;
try {
in = OpenHttpConnection ( URL );
} catch ( IOException e1 ) {
// TODO Auto-generated catch block
e1.printStackTrace ();
return “”;
}

InputStreamReader isr = new InputStreamReader(in);
int charRead;
String str = “”;
char[] inputBuffer = new char[BUFFER_SIZE];
try {
while ( ( charRead = isr.read ( inputBuffer ) )>0 )
{
String readString = String.copyValueOf ( inputBuffer,  0,  charRead );
str += readString;
inputBuffer = new char [ BUFFER_SIZE ];
}
in.close();
} catch ( IOException e ) {
// TODO Auto-generated catch block
e.printStackTrace ();
return “”;
}
return str;
}
//The function below is used to access remote url and read data from the remote file
private InputStream OpenHttpConnection ( 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” );
// we can connect server via two methods: GET and POST, here connects server via GET method.
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 ex )
{
throw new IOException (  ”Error connecting”  );
}
return in;
}

}
XML file should be like following:
<?xml version = “1.0″ encoding = “utf-8″ ?>
<manifest xmlns:android = “http://schemas.android.com/apk/res/android”
package = “com.schogini.httpsData”
android:versionCode = “1″
android:versionName = “1.0.0″  >
<uses-permission android:name = “android.permission.INTERNET” />
<application android:icon = “@drawable/ic_launcher”
android:label = “@string/app_name” >
<activity android:name = “.httpsData”
android:label = “@string/app_name” >
<intent-filter>
<action android:name = “android.intent.action.MAIN” />
<category android:name = “android.intent.category.LAUNCHER” />
</intent-filter>
</activity>
</application>
</manifest>

In android you can select images from gallery and store it in your application as a part of your application image.

Create an xml file like following:

<LinearLayout xmlns:android = “http://schemas.android.com/apk/res/android”
xmlns:tools = “http://schemas.android.com/tools”
android:layout_width = “fill_parent”
android:layout_height = “fill_parent”>
<Button
android:id = “@+id/button1″
android:layout_width = “wrap_content”
android:layout_height = “wrap_content”
android:text = “Select Image from Gallery” />
</LinearLayout>

The mainActivity.java should be like following:

public class MainActivity extends Activity implements OnClickListener {

Button selectImage;
private static int SELECT_IMAGE = 1;
String imagePath;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);

setContentView(R.layout.activity_main);

selectImage = (Button) findViewById(R.id.Button1);
selectImage.setOnClickListener(this);

}

public void onClick(View v) {

Intent intent = new Intent();
intent.setType(“image/*”);
intent.setAction(Intent.ACTION_GET_CONTENT);
startActivityForResult(Intent.createChooser(intent, “Select Image”), SELECT_IMAGE);

}

public void onActivityResult(int requestCode, int resultCode, Intent data) {

if (resultCode == RESULT_OK) {

if (requestCode == SELECT_IMAGE) {
Uri selectedImageUri = data.getData();
imagePath = getPath(selectedImageUri);

Bitmap bmp = BitmapFactory.decodeFile(imagePath);
String file_path = Environment.getExternalStorageDirectory().getAbsolutePath() + “/KepnerTregoe/”;
File dir = new File(file_path);
if(!dir.exists())
dir.mkdirs();
File file = new File(dir, “myImage.png”); //name your image
try {
FileOutputStream fOut = new FileOutputStream(file);
bmp.compress(Bitmap.CompressFormat.PNG, 85, fOut);
fOut.flush();
fOut.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

Toast.makeText(getApplicationContext(), imagePath, Toast.LENGTH_SHORT).show();

}
}
}

public String getPath(Uri uri) {

String[] projection = { MediaStore.Images.Media.DATA };
Cursor cursor = managedQuery(uri, projection, null, null, null);
int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
cursor.moveToFirst();
return cursor.getString(column_index);
}
}

Use the org.json parser classes that are baked into Android. The SDK comes with a very efficient set of classes for parsing JSON formatted strings in the org.json package. Simply create a new JSONObject or JSONArray from the formatted string data and you’ll be armed with a set of accessor methods to get primitive data or nested JSONObjects and JSONArrays from within.

This JSON parser is strict by default, meaning that it will halt with an Exception when encountering invalid JSON data or an invalid key. Accessor methods that prefix with ”get” will throw a JSONException if the requested value is not found. In some cases this behavior is not ideal, and for the there is a companion set of methods that are prefixed with ”opt”. These methods will return null instead of throwing an exception when a value for the requested key is not found. In addition, many of them have an overloaded version that also takes a fallback parameter to return instead of null.

{
“person”: {
“name”: “John”,
“age”: 30,
“children”: [
{
"name": "Ben"
"age": 5
},
{
"name": "Sarah"
"age": 7
},
{
"name": "Tom"
"age": 9
}
]
}
}

This defines a single object with three values: name (String), age (Integer), and children. The parameter entitled ”children” is an array of three more objects, each with their own name and age.

<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
android:orientation=”vertical”>
<TextView
android:id=”@+id/line1″
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
/>
<TextView
android:id=”@+id/line2″
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
/>
<TextView
android:id=”@+id/line3″
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”T
/>
</LinearLayout>

public class MyActivity extends Activity {
private static final String JSON_STRING =
“{\”person\”:{\”name\”:\”Tom\”,\”age\”:30,\”children\”:
[{\"name\":\"Ben\",\"age\":5}," + "\"name\":\"Sarah\",\"age\":7},
{\"name\":\"Tom\",\"age\":9}]}}”;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
TextView line1 = (TextView)findViewById(R.id.line1);
TextView line2 = (TextView)findViewById(R.id.line2);
TextView line3 = (TextView)findViewById(R.id.line3);
try {
JSONObject person = (new JSONObject(JSON_STRING)).getJSONObject(“person”);
String name = person.getString(“name”);
line1.setText(“This person’s name is ” + name);
line2.setText(name + ” is ” + person.getInt(“age”) + ” years old.”);
line3.setText(name + ” has ” + person.getJSONArray(“children”).length()
+ ” children.”);
} catch (JSONException e) {
e.printStackTrace();
}
}
}
For this example, the JSON string has been hard-coded as a constant. When the
Activity is created, the string is turned into a JSONObject, at which point all its data can be accessed as key-value pairs, just as if it were stored in a Map or Dictionary. All the business logic is wrapped in a try/catch statement since we are using the strict methods for accessing data.

Functions like JSONObject.getString() and JSONObject.getInt() are used to reads
primitive data out and place it in the TextView; the getJSONArray() method pulls out the nested ”children” array. JSONArray has the same set of accessor methods as JSONObject to read data, but they take an index into the array as a parameter instead of the name of the key.

The custom objects are basically 3D boxes in 4 different colors. They rotate and
so on depending on the view of the marker.
public class CustomObject1 extends ARObject {
public CustomObject1(String name, String patternName,
double markerWidth, double[] markerCenter) {
super(name, patternName, markerWidth, markerCenter);
float mat_ambientf[] = {0f, 1.0f, 0f, 1.0f};
float mat_flashf[] = {0f, 1.0f, 0f, 1.0f};
float mat_diffusef[] = {0f, 1.0f, 0f, 1.0f};
float mat_flash_shinyf[] = {50.0f};
mat_ambient = GraphicsUtil.makeFloatBuffer(mat_ambientf);
mat_flash = GraphicsUtil.makeFloatBuffer(mat_flashf);
mat_flash_shiny =
GraphicsUtil.makeFloatBuffer(mat_flash_shinyf);
mat_diffuse = GraphicsUtil.makeFloatBuffer(mat_diffusef);
}
public CustomObject1(String name, String patternName,
double markerWidth, double[] markerCenter, float[]
customColor) {
super(name, patternName, markerWidth, markerCenter);
float mat_flash_shinyf[] = {50.0f};
mat_ambient = GraphicsUtil.makeFloatBuffer(customColor);
mat_flash = GraphicsUtil.makeFloatBuffer(customColor);
mat_flash_shiny =
GraphicsUtil.makeFloatBuffer(mat_flash_shinyf);
mat_diffuse = GraphicsUtil.makeFloatBuffer(customColor);
}
private SimpleBox box = new SimpleBox();
private FloatBuffer mat_flash;
private FloatBuffer mat_ambient;
private FloatBuffer mat_flash_shiny;
private FloatBuffer mat_diffuse;
@Override
public final void draw(GL10 gl) {
super.draw(gl);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_SPECULAR,mat_flash);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_SHININESS, mat_flash_shiny);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_DIFFUSE, mat_diffuse);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_AMBIENT, mat_ambient);
gl.glColor4f(0, 1.0f, 0, 1.0f);
gl.glTranslatef( 0.0f, 0.0f, 12.5f );
box.draw(gl);
}
@Override
public void init(GL10 gl) {
}
}
The other three CustomObject classes are exactly the same as CustomObject1, except we change the colors a bit. Following are the changes you need to make for CustomObject2.
public CustomObject2(String name, String patternName,
double markerWidth, double[] markerCenter) {
super(name, patternName, markerWidth, markerCenter);
float mat_ambientf[] = {1.0f, 0f, 0f, 1.0f};
float mat_flashf[] = {1.0f, 0f, 0f, 1.0f};
float mat_diffusef[] = {1.0f, 0f, 0f, 1.0f};
float mat_flash_shinyf[] = {50.0f};
mat_ambient = GraphicsUtil.makeFloatBuffer(mat_ambientf);
mat_flash = GraphicsUtil.makeFloatBuffer(mat_flashf);
mat_flash_shiny =
GraphicsUtil.makeFloatBuffer(mat_flash_shinyf);
mat_diffuse = GraphicsUtil.makeFloatBuffer(mat_diffusef);
}
//Same code everywhere else, except the draw() method
@Override
public final void draw(GL10 gl) {
super.draw(gl);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_SPECULAR,mat_flash);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_SHININESS, mat_flash_shiny);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_DIFFUSE, mat_diffuse);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_AMBIENT, mat_ambient);
gl.glColor4f(1.0f, 0, 0, 1.0f);
gl.glTranslatef( 0.0f, 0.0f, 12.5f );
box.draw(gl);
}
public CustomObject3(String name, String patternName,
double markerWidth, double[] markerCenter) {
super(name, patternName, markerWidth, markerCenter);
float mat_ambientf[] = {0f, 0f, 1.0f, 1.0f};
float mat_flashf[] = {0f, 0f, 1.0f, 1.0f};
float mat_diffusef[] = {0f, 0f, 1.0f, 1.0f};
float mat_flash_shinyf[] = {50.0f};
mat_ambient = GraphicsUtil.makeFloatBuffer(mat_ambientf);
mat_flash = GraphicsUtil.makeFloatBuffer(mat_flashf);
mat_flash_shiny = GraphicsUtil.makeFloatBuffer(mat_flash_shinyf);
mat_diffuse = GraphicsUtil.makeFloatBuffer(mat_diffusef);
}
//Same code everywhere else, except the draw() method
@Override
public final void draw(GL10 gl) {
super.draw(gl);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK,
GL10.GL_SPECULAR,mat_flash);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_SHININESS, mat_flash_shiny);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_DIFFUSE, mat_diffuse);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_AMBIENT, mat_ambient);
gl.glColor4f(0f, 0, 1.0, 1.0f);
gl.glTranslatef( 0.0f, 0.0f, 12.5f );
box.draw(gl);
}
And finally, the changes for CustomObject4 follow:
public CustomObject4(String name, String patternName,
double markerWidth, double[] markerCenter) {
super(name, patternName, markerWidth, markerCenter);
float mat_ambientf[] = {1.0f, 0f, 1.0f, 1.0f};
float mat_flashf[] = {1.0f, 0f, 1.0f, 1.0f};
float mat_diffusef[] = {1.0f, 0f, 1.0f, 1.0f};
float mat_flash_shinyf[] = {50.0f};
mat_ambient = GraphicsUtil.makeFloatBuffer(mat_ambientf);
mat_flash = GraphicsUtil.makeFloatBuffer(mat_flashf);
mat_flash_shiny = GraphicsUtil.makeFloatBuffer(mat_flash_shinyf);
mat_diffuse = GraphicsUtil.makeFloatBuffer(mat_diffusef);
}
//Same code everywhere else, except the draw() method
@Override
public final void draw(GL10 gl) {
super.draw(gl);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_SPECULAR,mat_flash);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_SHININESS, mat_flash_shiny);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_DIFFUSE, mat_diffuse);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_AMBIENT, mat_ambient);
gl.glColor4f(1.0f, 0, 1.0, 1.0f);
gl.glTranslatef( 0.0f, 0.0f, 12.5f );
box.draw(gl);
}
Now we have only CustomRenderer.java to deal with. This class allows us to do any non-AR stuff as well as set up the OpenGL environment.
public class CustomRenderer implements OpenGLRenderer {
private float[] ambientlight1 = {.3f, .3f, .3f, 1f};
private float[] diffuselight1 = {.7f, .7f, .7f, 1f};
private float[] specularlight1 = {0.6f, 0.6f, 0.6f, 1f};
private float[] lightposition1 = {20.0f,-40.0f,100.0f,1f};
private FloatBuffer lightPositionBuffer1 =
GraphicsUtil.makeFloatBuffer(lightposition1);
private FloatBuffer specularLightBuffer1 =
GraphicsUtil.makeFloatBuffer(specularlight1);
private FloatBuffer diffuseLightBuffer1 =
GraphicsUtil.makeFloatBuffer(diffuselight1);
private FloatBuffer ambientLightBuffer1 =
GraphicsUtil.makeFloatBuffer(ambientlight1);
public final void draw(GL10 gl) {
}
public final void setupEnv(GL10 gl) {
gl.glEnable(GL10.GL_LIGHTING);
gl.glLightfv(GL10.GL_LIGHT1, GL10.GL_AMBIENT,
ambientLightBuffer1);
gl.glLightfv(GL10.GL_LIGHT1, GL10.GL_DIFFUSE,
diffuseLightBuffer1);
gl.glLightfv(GL10.GL_LIGHT1, GL10.GL_SPECULAR,
specularLightBuffer1);
gl.glLightfv(GL10.GL_LIGHT1, GL10.GL_POSITION,
lightPositionBuffer1);
gl.glEnable(GL10.GL_LIGHT1);
gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
gl.glDisable(GL10.GL_TEXTURE_2D);
initGL(gl);
}
public final void initGL(GL10 gl) {
gl.glDisable(GL10.GL_COLOR_MATERIAL);
gl.glEnable(GL10.GL_CULL_FACE);
gl.glShadeModel(GL10.GL_SMOOTH);
gl.glDisable(GL10.GL_COLOR_MATERIAL);
gl.glEnable(GL10.GL_LIGHTING);
gl.glEnable(GL10.GL_CULL_FACE);
gl.glEnable(GL10.GL_DEPTH_TEST);
gl.glEnable(GL10.GL_NORMALIZE);
}
}
In the variable declarations, we specify the different types of lighting and create FloatBuffers from them. The setupEnv() is called before we display any of the boxes. It sets up the lighting and other OpenGL-specific stuff. The initGL() method is called once when the Surface is created.
Finally, the AndroidManifest.xml needs to be updated:
<?xml version=”1.0″ encoding=”utf-8″?>
<manifest xmlns:android=”http://schemas.android.com/apk/res/android”
package=”com.paar.ch3marker”
android:versionCode = “1″
android:versionName = “1.0″ >
<uses-sdk android:minSdkVersion=”7″ />
<application
android:icon = “@drawable/ic_launcher”
android:label = “@string/app_name” >
<activity
android:label = “@string/app_name”
android:name = “.Activity”
android:clearTaskOnLaunch = “true”
android:screenOrientation = “landscape”
android:noHistory = “true”>
<intent-filter >
<action android:name = “android.intent.action.MAIN” />
<category android:name = “android.intent.category.LAUNCHER” />
</intent-filter>
</activity>
</application>
<uses-permission android:name = “android.permission.CAMERA”/>
<uses-permission android:name = “android.permission.WRITE_EXTERNAL_STORAGE”/>
<uses-feature android:name = “android.hardware.camera” />
<uses-feature android:name = “android.hardware.camera.autofocus” />
</manifest>

Markers are visual cues used by AR apps to know where to put overlays. You select any easily identifiable image (like a black question mark on a white background). One copy of the image is saved in your app, while another is printed out and put somewhere in the real world (or painted if you have a very steady hand). Marker recognition is an ongoing part of research in the field of artificial intelligence.
We will be using an open source Android library called AndAR to help us with the marker recognition. The details of the AndAR project can be found at http://code.google.com/p/andar. The application will have four markers that it will recognize. For each of the markers, we will supply a .patt file that AndAR can use to recognize the markers. These files describe how the markers look in a way that AndAR can understand. You can also create and supply your own markers, if you don’t like the ones provided or are feeling bored and adventurous. There are a few limitations, though:
a. The marker must be square in shape.
b. The borders must contrast well.
c. The border must be a solid color.

The markers can be black and white or color.

public class Activity extends AndARActivity {
private ARObject someObject;
private ARToolkit artoolkit;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
CustomRenderer renderer = new CustomRenderer();
setNonARRenderer(renderer);
try {
artoolkit = getArtoolkit();
someObject = new CustomObject1
(“test”, “marker_at16.patt”, 80.0, new double[]{0,0});
artoolkit.registerARObject(someObject);
someObject = new CustomObject2
(“test”, “marker_peace16.patt”, 80.0, new
double[]{0,0});
artoolkit.registerARObject(someObject);
someObject = new CustomObject3
(“test”, “marker_rupee16.patt”, 80.0, new
double[]{0,0});
artoolkit.registerARObject(someObject);
someObject = new CustomObject4
(“test”, “marker_hand16.patt”, 80.0, new double[]{0,0});
artoolkit.registerARObject(someObject);
} catch (AndARException ex){
System.out.println(“”);
}
startPreview();
}
public void uncaughtException(Thread thread, Throwable ex) {
Log.e(“AndAR EXCEPTION”, ex.getMessage());
finish();
}
}
In the onCreate() method, we first get the savedInstanceState. After that, we create a reference to the CustomRenderer class, which we will create a few pages down the line. We then set the non-AR renderer. Now comes the main part of the class. We register all four of the markers with AndAR and their related objects. CustomObject1-4 are classes that define what is to be augmented over each marker. Finally, the uncaughtException() method is used to cleanly exit the app if a fatal exception happens.

The Geocoder class provides a method to translate from an address into a latitude longitude coordinate ( geocoding ) and from a latitude longitude coordinate into an address ( reverse geo coding ). Reverse geo coding might produce only a partial address, such as city and postal code, depending on the level of detail available to the location provider.
This script uses reverse geo coding to get an address from the device’s location and display to the screen. The Geocoder instance needs to be initiated with a context and optionally with a locale if different from the system locale. Here, it is explicitly set to Locale.ENGLISH. Then the getFromLocation() method provides a list of addresses associated with the area around the provided location. Here the maximum number of returned results is set to one ( for instance, the most likely address ).
The Geocoder returns a List of android.location.Address objects.This translation to an address depends on a backend service that is not included in the core Android framework.The Google Maps API provides a client Geocoder service, for example. However,
the translation returns an empty list if no such service exists on the target device. The address as a list of strings is dumped line by line into a String for display on the screen.

public class MyLocation extends Activity {
LocationManager mLocationManager;
Location mLocation;
TextView tv;
@Override
public void onCreate ( Bundle savedInstanceState ) {
super.onCreate ( savedInstanceState );
setContentView ( R.layout.main );
tv = ( TextView ) findViewById( R.id.tv1 );
mLocationManager = ( LocationManager )
getSystemService ( Context.LOCATION_SERVICE );
Criteria criteria = new Criteria();
criteria.setAccuracy ( Criteria.ACCURACY_FINE );
criteria.setPowerRequirement ( Criteria.POWER_LOW );
String locationprovider =
mLocationManager.getBestProvider (criteria, true);
mLocation =
mLocationManager.getLastKnownLocation ( locationprovider );
List<Address> addresses;
try {
Geocoder mGC = new Geocoder ( this, Locale.ENGLISH );
addresses = mGC.getFromLocation ( mLocation.getLatitude (),
mLocation.getLongitude (), 1 );
if ( addresses != null ) {
Address currentAddr = addresses.get (0);
StringBuilder mSB = new StringBuilder (“Address:\n”);
for ( int i=0; i< currentAddr.getMaxAddressLineIndex();  i++ ) {
mSB.append ( currentAddr.getAddressLine ( i ) ).append (“\n”);
}
tv.setText ( mSB.toString() );
}
} catch( IOException e ) {
tv.setText ( e.getMessage() );
}
}
}