/* Copyright (C) 2003-2013 Runtime Revolution 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 java.net.*;

import java.io.*;

import java.nio.*;

import java.nio.charset.*;

import java.lang.reflect.*;

import java.util.*;

// 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

{

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 PowerManager.WakeLock m_wake_lock;

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

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);

// 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());

}

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

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;

}

}

public 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;

}

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;

((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;

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);

imm.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT);

}

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 control functionality

void addNativeControl(Object p_control)

{

m_native_control_module.addControl(p_control);

}

void removeNativeControl(Object p_control)

{

m_native_control_module.removeControl(p_control);

}

Object createBrowserControl()

{

return m_native_control_module.createBrowser();

}

Object createScrollerControl()

{

return m_native_control_module.createScroller();

}

Object createPlayerControl()

{

return m_native_control_module.createPlayer();

}

Object createInputControl()

{

return m_native_control_module.createInput();

}

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

// IM-2013-04-17: [[ AdModule ]] attempt to load AdModule class, returning null if the class cannot be found

Object loadAdModule()

{

try

{

Class t_ad_module_class;

Constructor t_ad_module_constructor;

t_ad_module_class = Class.forName("com.runrev.android.AdModule");

t_ad_module_constructor = t_ad_module_class.getConstructor(new Class[] {Engine.class, ViewGroup.class});

return t_ad_module_constructor.newInstance(new Object[] {this, ((LiveCodeActivity)getContext()).s_main_layout});

}

catch (Exception e)

{

return null;

}

}

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

// Called by MCScreenDC::popupanswerdialog()

public void popupAnswerDialog(String p_title, String p_message, String p_ok_button, String p_cancel_button, String p_other_button)

{

m_dialog_module.showAnswerDialog(p_title, p_message, p_ok_button, p_cancel_button, p_other_button);

}

public void onAnswerDialogDone(int p_which)

{

doAnswerDialogDone(p_which);

}

public void popupAskDialog(boolean p_is_password, String p_title, String p_message, String p_initial, boolean p_hint)

{

m_dialog_module.showAskDialog(p_is_password, p_title, p_message, p_initial, p_hint);

}

public void onAskDialogDone(String p_result)

{

doAskDialogDone(p_result);

}

public void showDatePicker(boolean p_with_min, boolean p_with_max, int p_min, int p_max, int p_current)

{

m_dialog_module.showDatePicker(p_with_min, p_with_max, p_min, p_max, p_current);

}

public void onDatePickerDone(int p_year, int p_month, int p_day, boolean p_done)

{

doDatePickerDone(p_year, p_month, p_day, p_done);

if (m_wake_on_event)

doProcess(false);

}

public void showTimePicker(int p_hour, int p_minute)

{

m_dialog_module.showTimePicker(p_hour, p_minute);

}

public void onTimePickerDone(int p_hour, int p_minute, boolean p_done)

{

doTimePickerDone(p_hour, p_minute, p_done);

if (m_wake_on_event)

doProcess(false);

}

public void showListPicker(List p_items, String p_title, boolean p_item_selected, int p_selection_index, boolean p_use_checkmark, boolean p_use_cancel, boolean p_use_done)

{

String[] t_items;

t_items = (String[])p_items.toArray(new String[p_items.size()]);

m_dialog_module.showListPicker(t_items, p_title, p_item_selected, p_selection_index, p_use_checkmark, p_use_cancel, p_use_done);

}

public void onListPickerDone(int p_index, boolean p_done)