Add support for Android 2.3+

There have been plenty of ppl involved in creating this version.
I don't wanna mention names as I'm sure I'd forget someone so I
just tell where help has been done:
- The partial android versions done by various ppl
- Testing on different android devices
- reviewing code (especially the in core changes)
- testing controls
- reviewing texts

A big thank you to everyone helping this to be completed!

3 files changed, 472 insertions, 0 deletions

diff --git a/build/android/src/org/minetest/minetest/MinetestAssetCopy.java b/build/android/src/org/minetest/minetest/MinetestAssetCopy.java
new file mode 100644
index 000000000..652a00831
--- /dev/null
+++ b/build/android/src/org/minetest/minetest/MinetestAssetCopy.java
@@ -0,0 +1,288 @@
+package org.minetest.minetest;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.util.Vector;
+
+import android.app.Activity;
+import android.content.res.AssetFileDescriptor;
+
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.os.Environment;
+import android.util.Log;
+import android.view.Display;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+
+public class MinetestAssetCopy extends Activity {
+	
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		
+		setContentView(R.layout.assetcopy);
+		
+		m_ProgressBar = (ProgressBar) findViewById(R.id.progressBar1);
+		m_Filename = (TextView) findViewById(R.id.textView1);
+		
+		Display display = getWindowManager().getDefaultDisplay();
+		m_ProgressBar.getLayoutParams().width = (int) (display.getWidth() * 0.8);
+		m_ProgressBar.invalidate();
+		
+		m_AssetCopy = new copyAssetTask();
+		m_AssetCopy.execute();
+	}
+	
+	ProgressBar m_ProgressBar;
+	TextView m_Filename;
+	
+	copyAssetTask m_AssetCopy;
+	
+	private class copyAssetTask extends AsyncTask<String, Integer, String>{
+		
+		private void copyElement(String name, String path) {
+			String baseDir = Environment.getExternalStorageDirectory().getAbsolutePath();
+			String full_path;
+			if (path != "") {
+				full_path = path + "/" + name;
+			}
+			else {
+				full_path = name;
+			}
+			//is a folder read asset list
+			if (m_foldernames.contains(full_path)) {
+				m_Foldername = full_path;
+				publishProgress(0);
+				File current_folder = new File(baseDir + "/" + full_path);
+				if (!current_folder.exists()) {
+					if (!current_folder.mkdirs()) {
+						Log.w("MinetestAssetCopy","\t failed create folder: " + baseDir + "/" + full_path);
+					}
+					else {
+						Log.w("MinetestAssetCopy","\t created folder: " + baseDir + "/" + full_path);
+					}
+				}
+				try {
+					String[] current_assets = getAssets().list(full_path);
+					for(int i=0; i < current_assets.length; i++) {
+						copyElement(current_assets[i],full_path);
+					}
+				} catch (IOException e) {
+					Log.w("MinetestAssetCopy","\t failed to read contents of folder");
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+			}
+			//is a file just copy
+			else {
+				boolean refresh = true;
+				
+				File testme = new File(baseDir + "/" + full_path);
+				
+				long asset_filesize = -1;
+				long stored_filesize = -1;
+				
+				if (testme.exists()) {
+					try {
+						AssetFileDescriptor fd = getAssets().openFd(full_path);
+						asset_filesize = fd.getLength();
+						fd.close();
+					} catch (IOException e) {
+						refresh = true;
+						m_asset_size_unknown.add(full_path);
+					}
+					
+					stored_filesize = testme.length();
+					
+					if (asset_filesize == stored_filesize) {
+						refresh = false;
+					}
+					
+				}
+				
+				if (refresh) {
+					m_tocopy.add(full_path);
+				}
+			}
+		}
+		
+		private long getFullSize(String filename) {
+			long size = 0;
+			try {
+			InputStream src = getAssets().open(filename);
+			byte[] buf = new byte[1024];
+			
+			int len = 0;
+			while ((len = src.read(buf)) > 0) {
+				size += len;
+			}
+			}
+			catch (IOException e) {
+				e.printStackTrace();
+			}
+			return size;
+		}
+
+		@Override
+		protected String doInBackground(String... files) {
+			
+			m_foldernames  = new Vector<String>();
+			m_tocopy       = new Vector<String>();
+			m_asset_size_unknown = new Vector<String>();
+			String baseDir = Environment.getExternalStorageDirectory().getAbsolutePath() + "/";
+			
+			File TempFolder = new File(baseDir + "Minetest/tmp/");
+			
+			if (!TempFolder.exists()) {
+				TempFolder.mkdir();
+			}
+			else {
+				File[] todel = TempFolder.listFiles();
+				
+				for(int i=0; i < todel.length; i++) {
+					Log.w("MinetestAssetCopy","deleting: " + todel[i].getAbsolutePath());
+					todel[i].delete();
+				}
+			}
+			
+			// add a .nomedia file
+			try {
+				OutputStream dst = new FileOutputStream(baseDir + "Minetest/.nomedia");
+				dst.close();
+			} catch (IOException e) {
+				Log.w("MinetestAssetCopy","Failed to create .nomedia file");
+				e.printStackTrace();
+			}
+			
+			try {
+				InputStream is = getAssets().open("index.txt");
+				BufferedReader reader = new BufferedReader(new InputStreamReader(is));
+		
+				String line = reader.readLine();
+				while(line != null){
+					m_foldernames.add(line);
+					line = reader.readLine();
+				}
+			} catch (IOException e1) {
+				// TODO Auto-generated catch block
+				e1.printStackTrace();
+			}
+			
+			copyElement("Minetest","");
+			
+			m_copy_started = true;
+			m_ProgressBar.setMax(m_tocopy.size());
+			
+			for (int i = 0; i < m_tocopy.size(); i++) {
+				try {
+					String filename = m_tocopy.get(i);
+					publishProgress(i);
+					
+					boolean asset_size_unknown = false;
+					long filesize = -1;
+					
+					if (m_asset_size_unknown.contains(filename)) {
+						File testme = new File(baseDir + "/" + filename);
+						
+						if(testme.exists()) {
+							filesize = testme.length();
+						}
+						asset_size_unknown = true;
+					}
+					
+					InputStream src;
+					try {
+						src = getAssets().open(filename);
+					} catch (IOException e) {
+						Log.w("MinetestAssetCopy","Copying file: " + filename + " FAILED (not in assets)");
+						// TODO Auto-generated catch block
+						e.printStackTrace();
+						continue;
+					}
+					
+					// Transfer bytes from in to out
+					byte[] buf = new byte[1*1024];
+					int len = src.read(buf, 0, 1024);
+					
+					/* following handling is crazy but we need to deal with    */
+					/* compressed assets.Flash chips limited livetime sue to   */
+					/* write operations, we can't allow large files to destroy */
+					/* users flash.                                            */
+					if (asset_size_unknown) {
+						if ( (len > 0) && (len < buf.length) && (len == filesize)) {
+							src.close();
+							continue;
+						}
+						
+						if (len == buf.length) {
+							src.close();
+							long size = getFullSize(filename);
+							if ( size == filesize) {
+								continue;
+							}
+							src = getAssets().open(filename);
+							len = src.read(buf, 0, 1024);
+						}
+					}
+					if (len > 0) {
+						int total_filesize = 0;
+						OutputStream dst;
+						try {
+							dst = new FileOutputStream(baseDir + "/" + filename);
+						} catch (IOException e) {
+							Log.w("MinetestAssetCopy","Copying file: " + baseDir + 
+							"/" + filename + " FAILED (couldn't open output file)");
+							e.printStackTrace();
+							src.close();
+							continue;
+						}
+						dst.write(buf, 0, len);
+						total_filesize += len;
+						
+						while ((len = src.read(buf)) > 0) {
+							dst.write(buf, 0, len);
+							total_filesize += len;
+						}
+						
+						dst.close();
+						Log.w("MinetestAssetCopy","Copied file: " + m_tocopy.get(i) + " (" + total_filesize + " bytes)");
+					}
+					else if (len < 0) {
+						Log.w("MinetestAssetCopy","Copying file: " + m_tocopy.get(i) + " failed, size < 0");
+					}
+					src.close();
+				} catch (IOException e) {
+					Log.w("MinetestAssetCopy","Copying file: " + m_tocopy.get(i) + " failed");
+					e.printStackTrace();
+				}
+			}
+			
+			return "";
+		}
+		
+		protected void onProgressUpdate(Integer... progress) {
+			if (m_copy_started) {
+				m_ProgressBar.setProgress(progress[0]);
+				m_Filename.setText(m_tocopy.get(progress[0]));
+			}
+			else {
+				m_Filename.setText("scanning " + m_Foldername + " ...");
+			}
+		}
+		
+		protected void onPostExecute (String result) {
+			finish();
+		}
+		boolean m_copy_started = false;
+		String m_Foldername = "media";
+		Vector<String> m_foldernames;
+		Vector<String> m_tocopy;
+		Vector<String> m_asset_size_unknown;
+	}
+}
diff --git a/build/android/src/org/minetest/minetest/MinetestTextEntry.java b/build/android/src/org/minetest/minetest/MinetestTextEntry.java
new file mode 100644
index 000000000..db175a483
--- /dev/null
+++ b/build/android/src/org/minetest/minetest/MinetestTextEntry.java
@@ -0,0 +1,91 @@
+package org.minetest.minetest;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.text.InputType;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.View.OnKeyListener;
+import android.widget.EditText;
+
+public class MinetestTextEntry extends Activity {
+	public AlertDialog mTextInputDialog;
+	public EditText mTextInputWidget;
+	
+	private final int MultiLineTextInput              = 1;
+	private final int SingleLineTextInput             = 2;
+	private final int SingleLinePasswordInput         = 3;
+	
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		
+		Bundle b = getIntent().getExtras();
+		String acceptButton = b.getString("EnterButton");
+		String hint         = b.getString("hint");
+		String current      = b.getString("current");
+		int    editType     = b.getInt("editType");
+		
+		AlertDialog.Builder builder = new AlertDialog.Builder(this);
+		mTextInputWidget = new EditText(this);
+		mTextInputWidget.setHint(hint);
+		mTextInputWidget.setText(current);
+		mTextInputWidget.setMinWidth(300);
+		if (editType == SingleLinePasswordInput) {
+			mTextInputWidget.setInputType(InputType.TYPE_CLASS_TEXT | 
+					InputType.TYPE_TEXT_VARIATION_PASSWORD);
+		}
+		else {
+			mTextInputWidget.setInputType(InputType.TYPE_CLASS_TEXT);
+		}
+		
+		
+		builder.setView(mTextInputWidget);
+		
+		if (editType == MultiLineTextInput) {
+			builder.setPositiveButton(acceptButton, new DialogInterface.OnClickListener() {
+				public void onClick(DialogInterface dialog, int whichButton) 
+				{ pushResult(mTextInputWidget.getText().toString()); }
+				});
+		}
+		
+		builder.setOnCancelListener(new DialogInterface.OnCancelListener() {
+			public void onCancel(DialogInterface dialog) {
+				cancelDialog();
+			}
+		});
+		
+		mTextInputWidget.setOnKeyListener(new OnKeyListener() {
+			@Override
+			public boolean onKey(View view, int KeyCode, KeyEvent event) {
+				if ( KeyCode == KeyEvent.KEYCODE_ENTER){
+
+					pushResult(mTextInputWidget.getText().toString());
+					return true;
+				}
+				return false;
+			}
+		});
+		
+		mTextInputDialog = builder.create();
+		mTextInputDialog.show();
+	}
+	
+	public void pushResult(String text) {
+		Intent resultData = new Intent();
+		resultData.putExtra("text", text);
+		setResult(Activity.RESULT_OK,resultData);
+		mTextInputDialog.dismiss();
+		finish();
+	}
+	
+	public void cancelDialog() {
+		setResult(Activity.RESULT_CANCELED);
+		mTextInputDialog.dismiss();
+		finish();
+	}
+}
diff --git a/build/android/src/org/minetest/minetest/MtNativeActivity.java b/build/android/src/org/minetest/minetest/MtNativeActivity.java
new file mode 100644
index 000000000..ba7d62169
--- /dev/null
+++ b/build/android/src/org/minetest/minetest/MtNativeActivity.java
@@ -0,0 +1,93 @@
+package org.minetest.minetest;
+
+import android.app.NativeActivity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.WindowManager;
+
+public class MtNativeActivity extends NativeActivity {
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		m_MessagReturnCode = -1;
+		m_MessageReturnValue = "";
+		
+	}
+
+	@Override
+	public void onDestroy() {
+		super.onDestroy();
+	}
+	
+	
+	public void copyAssets() {
+		Intent intent = new Intent(this, MinetestAssetCopy.class);
+		startActivity(intent);
+	}
+	
+	public void showDialog(String acceptButton, String hint, String current,
+			int editType) {
+		
+		Intent intent = new Intent(this, MinetestTextEntry.class);
+		Bundle params = new Bundle();
+		params.putString("acceptButton", acceptButton);
+		params.putString("hint", hint);
+		params.putString("current", current);
+		params.putInt("editType", editType);
+		intent.putExtras(params);
+		startActivityForResult(intent, 101);
+		m_MessageReturnValue = "";
+		m_MessagReturnCode   = -1;
+	}
+	
+	public static native void putMessageBoxResult(String text);
+	
+	/* ugly code to workaround putMessageBoxResult not beeing found */
+	public int getDialogState() {
+		return m_MessagReturnCode;
+	}
+	
+	public String getDialogValue() {
+		m_MessagReturnCode = -1;
+		return m_MessageReturnValue;
+	}
+	
+	public float getDensity() {
+		return getResources().getDisplayMetrics().density;
+	}
+	
+	public int getDisplayWidth() {
+		return getResources().getDisplayMetrics().widthPixels;
+	}
+	
+	public int getDisplayHeight() {
+		return getResources().getDisplayMetrics().heightPixels;
+	}
+	
+	@Override
+	protected void onActivityResult(int requestCode, int resultCode,
+			Intent data) {
+		if (requestCode == 101) {
+			if (resultCode == RESULT_OK) {
+				String text = data.getStringExtra("text"); 
+				m_MessagReturnCode = 0;
+				m_MessageReturnValue = text;
+			}
+			else {
+				m_MessagReturnCode = 1;
+			}
+		}
+	}
+	
+	static {
+		System.loadLibrary("openal");
+		System.loadLibrary("ogg");
+		System.loadLibrary("vorbis");
+		System.loadLibrary("ssl");
+		System.loadLibrary("crypto");
+	}
+	
+	private int m_MessagReturnCode;
+	private String m_MessageReturnValue;
+}