/* Copyright (C) 2003-2015 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

package com.runrev.android;

import com.runrev.android.billing.*;

/*

import com.runrev.android.billing.C.ResponseCode;

import com.runrev.android.billing.PurchaseUpdate.Purchase;

import com.runrev.android.billing.BillingService.RestoreTransactions;

import com.runrev.android.billing.BillingService.GetPurchaseInformation;

import com.runrev.android.billing.BillingService.ConfirmNotification;

import com.runrev.android.billing.BillingService.RequestPurchase;

*/

import com.runrev.android.nativecontrol.NativeControlModule;

import com.runrev.android.nativecontrol.VideoControl;

import android.content.*;

import android.content.res.*;

import android.content.pm.*;

import android.database.*;

import android.util.*;

import android.graphics.*;

import android.graphics.drawable.*;

import android.view.*;

import android.view.inputmethod.*;

import android.os.*;

import android.app.*;

import android.text.*;

import android.widget.*;

import android.provider.*;

import android.hardware.*;

import android.media.*;

import android.net.*;

import android.telephony.SmsManager;

import android.os.Vibrator;

import android.os.Environment;

import android.provider.MediaStore.*;

import android.provider.MediaStore.Images.Media;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import java.net.*;

import java.io.*;

import java.nio.*;

import java.nio.charset.*;

import java.lang.reflect.*;

import java.util.*;

import java.text.Collator;

import java.security.KeyStore;

import java.security.cert.CertificateFactory;

import java.security.cert.Certificate;

import java.security.cert.X509Certificate;

import javax.net.ssl.TrustManagerFactory;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

import java.security.cert.CertificateException;

// This is the main class that interacts with the engine. Although only one

// instance of the engine is allowed, we still need an object on which we can

// invoke methods from the native code so we wrap all this up into a single

// view object.

public class Engine extends View implements EngineApi

{

public static final String TAG = "revandroid.Engine";

// This is true if the engine is not suspended.

private static boolean s_running;

private static Engine s_engine_instance;

private Handler m_handler;

private boolean m_wake_on_event;

private boolean m_wake_scheduled;

private boolean m_video_is_playing;

private VideoControl m_video_control;

private BusyIndicator m_busy_indicator_module;

private TextMessaging m_text_messaging_module;

private Alert m_beep_vibrate_module;

private Contact m_contact_module;

private CalendarEvents m_calendar_module;

private OpenGLView m_opengl_view;

private OpenGLView m_old_opengl_view;

private BitmapView m_bitmap_view;

private File m_temp_image_file;

private Email m_email;

private ShakeEventListener m_shake_listener;

private ScreenOrientationEventListener m_orientation_listener;

private boolean m_text_editor_visible;

private int m_text_editor_mode;

private SensorModule m_sensor_module;

private DialogModule m_dialog_module;

private NetworkModule m_network_module;

private NativeControlModule m_native_control_module;

private SoundModule m_sound_module;

private NotificationModule m_notification_module;

private NFCModule m_nfc_module;

private RelativeLayout m_view_layout;

private PowerManager.WakeLock m_wake_lock;

// AL-2013-14-07 [[ Bug 10445 ]] Sort international on Android

private Collator m_collator;

// MM-2015-06-11: [[ MobileSockets ]] Trust manager and last verification error, used for verifying ssl certificates.

private X509TrustManager m_trust_manager;

private String m_last_certificate_verification_error;

private boolean m_new_intent;

private int m_photo_width, m_photo_height;

////////////////////////////////////////////////////////////////////////////////

public Engine(Context p_context)

{

super(p_context);

s_engine_instance = this;

// Temporary for testing purposes

OpenGLView.listConfigs();

//

setFocusable(true);

setFocusableInTouchMode(true);

// Create the main handler, this simply calls the 'doProcess' method

// of the engine since we only use it for wake-up notifications.

m_handler = new Handler() {

public void handleMessage(Message p_message) {

m_wake_scheduled = false;

doProcess(true);

}

};

// create our text editor

// IM-2012-03-23: switch to monitoring the InputConnection to the EditText field to fix

// bugs introduced by the previous method of checking for changes to the field

m_text_editor_mode = 1;

m_text_editor_visible = false;

// initialise modules

m_sensor_module = new SensorModule(this);

m_dialog_module = new DialogModule(this);

m_network_module = new NetworkModule(this);

m_busy_indicator_module = new BusyIndicator (this);

m_text_messaging_module = new TextMessaging (this);

m_beep_vibrate_module = new Alert (this);

m_contact_module = new Contact (this, ((LiveCodeActivity)getContext()));

m_calendar_module = new CalendarEvents (this, ((LiveCodeActivity)getContext()));

m_native_control_module = new NativeControlModule(this, ((LiveCodeActivity)getContext()).s_main_layout);

m_sound_module = new SoundModule(this);

m_notification_module = new NotificationModule(this);

m_nfc_module = new NFCModule(this);

m_view_layout = null;

// MM-2012-08-03: [[ Bug 10316 ]] Initialise the wake lock object.

PowerManager t_power_manager = (PowerManager) p_context.getSystemService(p_context.POWER_SERVICE);

m_wake_lock = t_power_manager.newWakeLock(PowerManager.FULL_WAKE_LOCK, TAG);

// Create listeners for shake events

m_shake_listener = new ShakeEventListener(p_context)

{

public void onShake(int type, long timestamp)

{

doShake(type, timestamp);

// Make sure we trigger handling

if (m_wake_on_event)

doProcess(false);

}

};

m_orientation_listener = new ScreenOrientationEventListener(p_context, 0)

{

public void onScreenOrientationChanged(int orientation)

{

doOrientationChanged(orientation);

if (m_wake_on_event)

doProcess(false);

}

};

m_shake_listener.setListening(true);

// We have no opengl view to begin with.

m_opengl_view = null;

m_old_opengl_view = null;

// But we do have a bitmap view.

m_bitmap_view = new BitmapView(getContext());

// AL-2013-14-07 [[ Bug 10445 ]] Sort international on Android

m_collator = Collator.getInstance(Locale.getDefault());

// MM-2015-06-11: [[ MobileSockets ]] Trust manager and last verification error, used for verifying ssl certificates.

m_trust_manager = null;

m_last_certificate_verification_error = null;

// MW-2013-10-09: [[ Bug 11266 ]] Turn off keep-alive connections to

// work-around a general bug in android:

// https://code.google.com/p/google-http-java-client/issues/detail?id=116

System.setProperty("http.keepAlive", "false");

m_new_intent = false;

m_photo_width = 0;

m_photo_height = 0;

}

////////////////////////////////////////////////////////////////////////////////

public void wakeEngineThread()

{

post(new Runnable() {

public void run()

{

if (m_wake_on_event)

doProcess(false);

}

});

}

public void nativeNotify(int p_callback, int p_context)

{

final int t_callback = p_callback;

final int t_context = p_context;

post(new Runnable() {

public void run()

{

s_engine_instance . doNativeNotify(t_callback, t_context);

}});

}

public static boolean isRunning()

{

return s_running;

}

public static Engine getEngine()

{

return s_engine_instance;

}

////////////////////////////////////////////////////////////////////////////////

public void showSplashScreen()

{

m_bitmap_view . showSplashScreen();

}

public void hideSplashScreen()

{

m_bitmap_view . hideSplashScreen();

}

////////////////////////////////////////////////////////////////////////////////

public void clearWakeUp()

{

if (m_wake_scheduled)

{

m_handler . removeMessages(0);

m_wake_scheduled = false;

}

}

// MM-2015-06-08: [[ MobileSockets ]] This can now potentially be called from several threads so make method synchronized.

public synchronized void scheduleWakeUp(int p_in_time, boolean p_any_event)

{

if (m_wake_scheduled)

{

m_handler . removeMessages(0);

m_wake_scheduled = false;

}

m_wake_scheduled = true;

m_wake_on_event = p_any_event;

m_handler . sendEmptyMessageDelayed(0, p_in_time);

}

public String getPackagePath()

{

return getContext() . getApplicationInfo() . sourceDir;

}

// IM-2016-03-04: [[ Bug 16917 ]] Return location of native libraries installed with this app

public String getLibraryPath()

{

return getContext() . getApplicationInfo() . nativeLibraryDir;

}

public void finishActivity()

{

// MM-2012-03-19: [[ Bug 10104 ]] Stop tracking any sensors on shutdown - not doing so prevents a restart for some reason.

if (m_sensor_module != null)

m_sensor_module.finish();

((LiveCodeActivity)getContext()).finish();

}

////////////////////////////////////////////////////////////////////////////////

public String loadExternalLibrary(String name)

{

try

{

System . loadLibrary(name);

return System . mapLibraryName(name);

}

catch ( UnsatisfiedLinkError e )

{

return null;

}

catch ( SecurityException e )

{

return null;

}

}

////////////////////////////////////////////////////////////////////////////////

public void onConfigurationChanged(Configuration p_new_config)

{

}

////////////////////////////////////////////////////////////////////////////////

public float getPixelDensity()

{

DisplayMetrics t_metrics;

t_metrics = new DisplayMetrics();

getWindowManager() . getDefaultDisplay() . getMetrics(t_metrics);

return t_metrics . density;

}

////////////////////////////////////////////////////////////////////////////////

public String getBuildInfo(String p_key)

{

try

{

if (p_key.startsWith("VERSION."))

{

Class t_version_class = Class.forName("android.os.Build$VERSION");

Field t_field = t_version_class.getField(p_key.substring(p_key.indexOf('.') + 1));

return t_field.get(null).toString();

}

else

{

Class t_build_class = Class.forName("android.os.Build");

Field t_field = t_build_class.getField(p_key);

return t_field.get(null).toString();

}

}

catch (Exception e)

{

Log.i("revandroid", e.toString());

return null;

}

}

////////////////////////////////////////////////////////////////////////////////

public int getDeviceRotation()

{

return m_orientation_listener.getOrientation();

}

public int getDisplayOrientation()

{

return getContext().getResources().getConfiguration().orientation;

}

public int getDisplayRotation()

{

WindowManager t_wm = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);

Display t_display = t_wm.getDefaultDisplay();

// screen rotation direction is opposite to device rotation

switch (t_display.getRotation())

{

case Surface.ROTATION_0:

return 0;

case Surface.ROTATION_90:

return 270;

case Surface.ROTATION_180:

return 180;

case Surface.ROTATION_270:

return 90;

}

return 0;

}

private static final int[] s_orientation_map = new int[] {

ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,

8, // ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE

9, // ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT

ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,

};

public void setDisplayOrientation(int p_orientation)

{

if ((p_orientation == 1 || p_orientation == 2) && Build.VERSION.SDK_INT < 9) // Build.VERSION_CODES.GINGERBREAD

return;

// MM-2014-03-25: [[ Bug 11708 ]] Moved call to update orientation (from onScreenOrientationChanged).

// This way we only flag orientation changed if the we've set it in the activity (i.e. or app has actually rotated).

// Prevents changes in device orientation during lock screen confusing things.

// IM-2013-11-15: [[ Bug 10485 ]] Record the change in orientation

updateOrientation(p_orientation);

((LiveCodeActivity)getContext()).setRequestedOrientation(s_orientation_map[p_orientation]);

}

////////////////////////////////////////////////////////////////////////////////

protected CharSequence m_composing_text;

@Override

public InputConnection onCreateInputConnection(EditorInfo outAttrs)

{

Log.i(TAG, "onCreateInputConnection()");

if (!m_text_editor_visible)

return null;

m_composing_text = null;

InputConnection t_connection = new BaseInputConnection(this, false) {

void handleKey(int keyCode, int charCode)

{

if (charCode == 0)

{

switch (keyCode)

{

case KeyEvent.KEYCODE_DEL:

keyCode = 0xff08;

break;

// Hao-2017-02-08: [[ Bug 11727 ]] Detect arrow key for field input

case KeyEvent.KEYCODE_DPAD_LEFT:

keyCode = 0xff51;

break;

case KeyEvent.KEYCODE_DPAD_UP:

keyCode = 0xff52;

break;

case KeyEvent.KEYCODE_DPAD_RIGHT:

keyCode = 0xff53;

break;

case KeyEvent.KEYCODE_DPAD_DOWN:

keyCode = 0xff54;

break;

default:

}

}

else if (charCode == 10)

{

// check for return key

charCode = 0;

keyCode = 0xff0d;

}

Log.i(TAG, "doing keypress for char " + charCode);

doKeyPress(0, charCode, keyCode);

}

@Override

public boolean sendKeyEvent(KeyEvent key)

{

int t_key_code = key.getKeyCode();

int t_char_code = key.getUnicodeChar();

if (key.getAction() == KeyEvent.ACTION_DOWN)

handleKey(t_key_code, t_char_code);

else if (key.getAction() == KeyEvent.ACTION_MULTIPLE)

{

// IM-2013-02-21: [[ BZ 10684 ]]

// allow BaseInputConnection to do the handling of commitText(), etc

// and instead catch the raw key events that are generated.

if (key.getKeyCode() == KeyEvent.KEYCODE_UNKNOWN)

{

// handle string of chars

CharSequence t_chars = key.getCharacters();

for (int i = 0; i < t_chars.length(); i++)

doKeyPress(0, t_chars.charAt(i), 0);

}

else

{

// handle repeated char

for (int i = 0; i < key.getRepeatCount(); i++)

handleKey(t_key_code, t_char_code);

}

}

if (m_wake_on_event)

doProcess(false);

return true;

}

// IM-2013-02-25: [[ BZ 10684 ]] - updated to show text changes in the field

// as software keyboards modify the composing text.

void updateComposingText(CharSequence p_new)

{

// send changes to the engine as a sequence of key events.

int t_match_length = 0;

int t_current_length = 0;

int t_new_length = 0;

int t_max_length = 0;

if (m_composing_text != null)

t_current_length = m_composing_text.length();

if (p_new != null)

t_new_length = p_new.length();

t_max_length = Math.min(t_current_length, t_new_length);

for (int i = 0; i < t_max_length; i++)

{

if (p_new.charAt(i) != m_composing_text.charAt(i))

break;

t_match_length += 1;

}

// send backspaces

for (int i = 0; i < t_current_length - t_match_length; i++)

doKeyPress(0, 0, 0xff08);

// send new text

for (int i = t_match_length; i < t_new_length; i++)

doKeyPress(0, p_new.charAt(i), 0);

m_composing_text = p_new;

if (m_wake_on_event)

doProcess(false);

}

// override input connection methods to catch changes to the composing text

@Override

public boolean commitText(CharSequence text, int newCursorPosition)

{

updateComposingText(text);

m_composing_text = null;

getEditable().clear();

return true;

}

@Override

public boolean finishComposingText()

{

m_composing_text = null;

getEditable().clear();

return true;

}

@Override

public boolean setComposingText(CharSequence text, int newCursorPosition)

{

updateComposingText(text);

return super.setComposingText(text, newCursorPosition);

}

};

int t_type = getInputType(false);

outAttrs.actionLabel = null;

outAttrs.inputType = t_type;

outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_EXTRACT_UI | EditorInfo.IME_FLAG_NO_ENTER_ACTION | EditorInfo.IME_ACTION_DONE;

return t_connection;

}

public void showKeyboard()

{

if (!m_text_editor_visible)

return;

requestFocus();

InputMethodManager imm;

imm = (InputMethodManager)getContext().getSystemService(Context.INPUT_METHOD_SERVICE);

if (imm != null)

imm.restartInput(this);

// HH-2017-01-18: [[ Bug 18058 ]] Fix keyboard not show in landscape orientation

imm.showSoftInput(this, InputMethodManager.SHOW_FORCED);

}

public void hideKeyboard()

{

// Hide the IME

InputMethodManager imm;

imm = (InputMethodManager)getContext().getSystemService(Context.INPUT_METHOD_SERVICE);

if (imm != null)

imm.restartInput(this);

imm.hideSoftInputFromWindow(getWindowToken(), 0);

}

public void resetKeyboard()

{

InputMethodManager imm;

imm = (InputMethodManager)getContext().getSystemService(Context.INPUT_METHOD_SERVICE);

if (imm != null)

imm.restartInput(this);

}

public void setTextInputVisible(boolean p_visible)

{

m_text_editor_visible = p_visible;

if (!s_running)

return;

if (p_visible)

showKeyboard();

else

hideKeyboard();

}

public void setTextInputMode(int p_mode)

{

// 0 is none

// 1 is text (normal)

// 2 is number

// 3 is decimal

// 4 is phone

// 5 is email

boolean t_reset = s_running && m_text_editor_visible && p_mode != m_text_editor_mode;

m_text_editor_mode = p_mode;

if (t_reset)

resetKeyboard();

}

public static final int TYPE_NUMBER_VARIATION_PASSWORD = 16;

public int getInputType(boolean p_password)

{

int t_type;

int t_mode = m_text_editor_mode;

// the phone class does not support a password variant, so we switch this for one of the number types

if (p_password && t_mode == 4)

t_mode = 2;

// the number password variant is not supported pre-honeycomb, so rather than show passwords in plain-text,

// we switch to the default text input type

if (p_password && Build.VERSION.SDK_INT < 11 && (t_mode == 2 || t_mode == 3))

t_mode = 1;

switch(t_mode)

{

default:

case 1:

t_type = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_MULTI_LINE | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS;

if (p_password)

t_type |= InputType.TYPE_TEXT_VARIATION_PASSWORD;

break;

case 2:

t_type = InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_SIGNED;

if (p_password)

t_type |= TYPE_NUMBER_VARIATION_PASSWORD;

break;

case 3:

t_type = InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_SIGNED | InputType.TYPE_NUMBER_FLAG_DECIMAL;

if (p_password)

t_type |= TYPE_NUMBER_VARIATION_PASSWORD;

break;

case 4:

t_type = InputType.TYPE_CLASS_PHONE;

break;

case 5:

t_type = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS;

if (p_password)

t_type |= InputType.TYPE_TEXT_VARIATION_PASSWORD;

break;

}

return t_type;

}

public void configureTextInput(int p_mode)

{

m_text_editor_mode = p_mode;

if (!s_running)

return;

if (p_mode == 0)

{

hideKeyboard();

}

else

{

// Show the IME

showKeyboard();

}

}

protected void onFocusChanged (boolean gainFocus, int direction, Rect previouslyFocusedRect)

{

if (!gainFocus)

{

hideKeyboard();

}

else if (gainFocus)

{

if (m_text_editor_visible)

showKeyboard();

else

hideKeyboard();

}

super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);

}

////////////////////////////////////////////////////////////////////////////////

// string utility functions

public int conversionByteCount(byte[] p_input, String p_in_charset, String p_out_charset)

{

Charset t_in_charset = Charset.forName(p_in_charset);

Charset t_out_charset = Charset.forName(p_out_charset);

if (t_in_charset == null || t_out_charset == null)

return 0;

CharsetDecoder t_decode = t_in_charset.newDecoder();

CharsetEncoder t_encode = t_out_charset.newEncoder();

t_decode.replaceWith("?");

try

{

CharBuffer t_utf16;

t_utf16 = t_decode.decode(ByteBuffer.wrap(p_input));

ByteBuffer t_encoded;

t_encoded = t_encode.encode(t_utf16);

return t_encoded.limit();

}

catch (CharacterCodingException e)

{

return 0;

}

}

public byte[] convertCharset(byte[] p_input, String p_in_charset, String p_out_charset)

{

Charset t_in_charset = Charset.forName(p_in_charset);

Charset t_out_charset = Charset.forName(p_out_charset);

if (t_in_charset == null || t_out_charset == null)

{

return null;

}

CharsetDecoder t_decode = t_in_charset.newDecoder();

CharsetEncoder t_encode = t_out_charset.newEncoder();

t_decode.onUnmappableCharacter(CodingErrorAction.REPLACE);

t_decode.replaceWith("?");

t_encode.onUnmappableCharacter(CodingErrorAction.REPLACE);

byte[] t_bytes = null;

try

{

CharBuffer t_utf16;

t_utf16 = t_decode.decode(ByteBuffer.wrap(p_input));

ByteBuffer t_encoded;

t_encoded = t_encode.encode(t_utf16);

t_bytes = new byte[t_encoded.limit()];

t_encoded.get(t_bytes);

}

catch (Exception e)

{

return null;

}

return t_bytes;

}

////////////////////////////////////////////////////////////////////////////////

static final String s_external_prefix = "external ";

public String getSpecialFolderPath(String p_name)

{

boolean t_external = false;

if (p_name.startsWith(s_external_prefix))

{

t_external = true;

p_name = p_name.substring(s_external_prefix.length());

}

try

{

if (p_name.equalsIgnoreCase("documents"))

{

if (t_external)

return getContext().getExternalFilesDir(null).getAbsolutePath();

else

return getContext().getFilesDir().getAbsolutePath();

}

else if (p_name.equalsIgnoreCase("temporary") || p_name.equalsIgnoreCase("cache"))

{

if (t_external)

return getContext().getExternalCacheDir().getAbsolutePath();

else

return getContext().getCacheDir().getAbsolutePath();

}

}

catch (Exception e)

{

return "";

}

return "";

}

////////////////////////////////////////////////////////////////////////////////

public int getAssetFileLength(String p_path)

{

int t_result;

try

{

AssetFileDescriptor t_descriptor;

t_descriptor = getContext() . getAssets() . openFd(p_path);

t_result = (int)t_descriptor . getLength();

t_descriptor . close();

}

catch(Exception e)

{

t_result = -1;

}

return t_result;

}

public int getAssetFileStartOffset(String p_path)

{

int t_result;

try

{

AssetFileDescriptor t_descriptor;

t_descriptor = getContext() . getAssets() . openFd(p_path);

t_result = (int)t_descriptor . getStartOffset();

t_descriptor . close();

}

catch(Exception e)

{

t_result = -1;

}

return t_result;

}

public int getAssetInfo(String p_filename, int p_field)

{

if (p_field == 0)

return getAssetFileStartOffset(p_filename);

else

return getAssetFileLength(p_filename);

}

////////////////////////////////////////////////////////////////////////////////

// asset file access functions

public boolean isAssetFile(String p_path)

{

try

{

InputStream t_fstream = getContext().getAssets().open(p_path);

t_fstream.close();

return true;

}

catch (IOException e)

{

return false;

}

}

public boolean isAssetFolder(String p_path)

{

if (isAssetFile(p_path))

return false;

try

{

// MW-2011-03-08: If the path has a trailing '/' then remove it

// as the asset manager doesn't like it like that.

if (p_path.endsWith("/"))

p_path = p_path.substring(0, p_path.length() - 1);

String[] t_contents = getContext().getAssets().list(p_path);

return t_contents.length > 0;

}

catch (IOException e)

{

return false;

}

}

public String getAssetFolderEntryList(String p_path)

{

if (!isAssetFolder(p_path))

return null;

// MW-2011-03-08: If the path has a trailing '/' then remove it

// as the asset manager doesn't like it like that.

if (p_path.endsWith("/"))

p_path = p_path.substring(0, p_path.length() - 1);

StringBuilder t_folderlist = new StringBuilder();

String[] t_contents;

try

{

t_contents = getContext().getAssets().list(p_path);

}

catch (IOException e)

{

return null;

}

for (String t_item : t_contents)

{

int t_item_size;

boolean t_is_folder;

String t_itempath;

if (p_path.length() == 0)

t_itempath=t_item;

else

t_itempath=p_path + '/' + t_item;

t_is_folder = !isAssetFile(t_itempath);

if (t_is_folder)

t_item_size = 0;

else

t_item_size = getAssetFileLength(t_itempath);

if (t_folderlist.length() > 0)

t_folderlist.append('\n');

t_folderlist.append(t_item);

t_folderlist.append('\n');

t_folderlist.append(Integer.toString(t_item_size) + "," + t_is_folder);

}

String t_result = t_folderlist.toString();

return t_result;

}

////////////////////////////////////////////////////////////////////////////////

// Native layer view functionality

Object getNativeLayerContainer()

{

if (m_view_layout == null)

{

FrameLayout t_main_view;

t_main_view = ((LiveCodeActivity)getContext()).s_main_layout;

m_view_layout = new RelativeLayout(getContext());

t_main_view.addView(m_view_layout, new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));

t_main_view.bringChildToFront(m_view_layout);

}

return m_view_layout;

}

Object createNativeLayerContainer()

{

return new RelativeLayout(getContext());

}

// insert the view into the container, layered below p_view_above if not null.

void addNativeViewToContainer(Object p_view, Object p_view_above, Object p_container)

{

ViewGroup t_container;

t_container = (ViewGroup)p_container;