rhodes 3.4.2 → 3.5.1.12

data/lib/extensions/net-http/net/https.rb

@@ -91,45 +91,11 @@ It can be replaced by the following code:
 require 'net/http'
 
 if System::get_property('platform') != 'Blackberry'
-    require 'openssl' 
+  require 'openssl' 
 else
-    module OpenSSL    
-        module SSL
-            VERIFY_NONE = 0
-        end
-    end
-end
-
-module Net
-  class HTTP
-    remove_method :use_ssl?
-    def use_ssl?
-      @use_ssl
-    end
-
-    # Turn on/off SSL.
-    # This flag must be set before starting session.
-    # If you change use_ssl value after session started,
-    # a Net::HTTP object raises IOError.
-    def use_ssl=(flag)
-      flag = (flag ? true : false)
-      if started? and @use_ssl != flag
-        raise IOError, "use_ssl value changed, but session already started"
-      end
-      @use_ssl = flag
-    end
-
-    SSL_ATTRIBUTES = %w(
-      ssl_version key cert ca_file ca_path cert_store ciphers
-      verify_mode verify_callback verify_depth ssl_timeout
-    )
-    attr_accessor(*SSL_ATTRIBUTES)
-
-    def peer_cert
-      if not use_ssl? or not @socket
-        return nil
-      end
-      @socket.io.peer_cert
+  module OpenSSL    
+    module SSL
+      VERIFY_NONE = 0
     end
   end
 end

data/lib/extensions/nfc/ext.yml

@@ -1,6 +1,8 @@
 entry: Init_Nfc	
-android_rhodes_activity_listener: com.rhomobile.nfc.Nfc
-android_manifest_changes: ext/nfc/platform/android/AndroidManifest.xml
-android_resources_addons: ext/nfc/platform/android/additional_files
-android_additional_sources_list: ext/nfc/platform/android/ext_build.files
+android:
+  exttype: rakefile
+  rhodes_listener: com.rhomobile.nfc.Nfc
+  manifest_changes: ext/nfc/platform/android/AndroidManifest.xml
+  adds: ext/nfc/platform/android/additional_files
+  source_list: ext/nfc/platform/android/ext_build.files
 libraries: ["Nfc"]

data/lib/extensions/nfc/ext/nfc/platform/android/jni/src/nfc.cpp

@@ -20,11 +20,11 @@
 
 #define logging_enable false
 
-void logi(const char* text) {
+static void logi(const char* text) {
 	if (logging_enable) __android_log_write(ANDROID_LOG_INFO, "NFC jni", text);
 } 
 
-void loge(const char* text) {
+static void loge(const char* text) {
 	__android_log_write(ANDROID_LOG_INFO, "NFC jni ERROR : ", text);
 } 
 

data/lib/extensions/nfc/ext/nfc/platform/android/src/com/rhomobile/nfc/NfcTechActivity.java

@@ -13,7 +13,6 @@ import android.os.Bundle;
 import android.os.Parcelable;
 import android.util.Log;
 
-import com.rhomobile.rhodes.PushService;
 import com.rhomobile.rhodes.RhodesActivity;
 import com.rhomobile.rhodes.RhodesService;
 

data/lib/extensions/openssl/openssl/ssl-internal.rb

@@ -79,7 +79,9 @@ module OpenSSL
       def initialize(*args)
         require "fcntl"
         flag = File::NONBLOCK
-        flag |= @io.fcntl(Fcntl::F_GETFL) if defined?(Fcntl::F_GETFL)
+        if (System::get_property('platform') != 'WINDOWS_DESKTOP') && !defined?( RHODES_EMULATOR )
+          flag |= @io.fcntl(Fcntl::F_GETFL) if defined?(Fcntl::F_GETFL)
+        end
         @io.fcntl(Fcntl::F_SETFL, flag)
         super
       end

data/lib/extensions/rawsensors/ext.yml

@@ -0,0 +1,4 @@
+entry: Init_RawSensors_extension	
+javaentry: com.rawsensors.RawSensors
+android_additional_sources_list: ext/rawsensors/platform/android/ext_build.files
+libraries: ["RawSensors"]

data/lib/extensions/rawsensors/ext/build

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+
+if [ "$RHO_PLATFORM" = "android" ]; then
+
+cd rawsensors/platform/android
+rake --trace
+
+elif [ "$RHO_PLATFORM" = "iphone" ]; then
+
+cd rawsensors/platform/iphone
+rake --trace
+
+fi
+
+
+

data/lib/extensions/rawsensors/ext/build.bat

@@ -0,0 +1,36 @@
+
+if "%RHO_PLATFORM%" == "android" (
+
+cd rawsensors\platform\android
+rake --trace
+
+)
+
+if "%RHO_PLATFORM%" == "iphone" (
+
+cd rawsensors\platform\phone
+rake --trace
+
+)
+
+if "%RHO_PLATFORM%" == "wm" (
+
+cd rawsensors\platform\wm
+rake --trace
+
+)
+
+if "%RHO_PLATFORM%" == "win32" (
+
+cd rawsensors\platform\wm
+rake --trace
+
+)
+
+if "%RHO_PLATFORM%" == "bb" (
+
+cd rawsensors\platform\bb
+rake --trace
+
+)
+

data/lib/extensions/rawsensors/ext/rawsensors/platform/android/Rakefile

@@ -0,0 +1,77 @@
+require 'fileutils'
+
+
+def build_extension(name, arch, src_files)
+  objects = []
+  mkdir_p $tempdir unless File.exists? $tempdir
+
+  use_own_stlport = false
+  $std_includes = File.join ENV['ANDROID_NDK'], "sources", "cxx-stl", "stlport", "stlport"
+  unless File.directory? $std_includes
+      $stlport_includes = "#{$rootdir}/platform/shared/stlport/stlport"
+      use_own_stlport = true
+  end
+
+  #Dir.glob("*.c").each do |f|
+  src_files.each do |f|
+    objname = File.join( $tempdir, File.basename( f.gsub(/\.c$/, '.o') ) )
+    objects << ('"'+objname+'"')
+
+    args = []
+    args << "-I."
+    args << "-I\"#{$rootdir}/platform/android/Rhodes/jni/include\""
+    args << "-I\"#{$rootdir}/platform/shared/ruby/include\""
+    args << "-I\"#{$rootdir}/platform/shared\""
+    args << "-I\"#{$rootdir}/platform/shared/common\""
+
+    args << "-I\"#{$std_includes}\"" unless $std_includes.nil?
+    args << "-D__NEW__" if use_own_stlport
+    args << "-I\"#{$stlport_includes}\"" if use_own_stlport
+
+    args << "-I\"#{$rootdir}/platform/shared/ruby/android\""
+    args << "-I\"#{$rootdir}/platform/shared/ruby/generated\""
+
+    cc_compile f, $tempdir, args or exit 1
+
+  end
+
+  mkdir_p $targetdir unless File.exist? $targetdir
+
+   cc_ar ('"'+File.join( $targetdir, 'lib' + name + '.a' )+'"'), Dir.glob($tempdir + "/**/*.o").collect{|x| '"'+x+'"'} or exit 1
+
+end
+
+namespace "build" do
+  task :config do
+    curdir = pwd
+    $rawsensorsdir = curdir.gsub('/ext/rawsensors/platform/android','');
+    $targetdir = ENV['TARGET_TEMP_DIR']
+    raise "TARGET_TEMP_DIR is not set" if $targetdir.nil?
+    $tempdir = ENV['TEMP_FILES_DIR']
+    raise "TEMP_FILES_DIR is not set" if $tempdir.nil?
+    $rootdir = ENV['RHO_ROOT']
+    raise "RHO_ROOT is not set" if $rootdir.nil?
+
+    require File.join($rootdir, 'platform/android/build/androidcommon.rb')
+
+    setup_ndk(ENV['ANDROID_NDK'],ENV['ANDROID_API_LEVEL'])
+
+  end
+
+  task :all => :config do
+
+    src_files = []
+
+    src_files << $rawsensorsdir + '/ext/rawsensors/platform/android/jni/src/rawsensors.cpp'
+    src_files << $rawsensorsdir + '/ext/rawsensors/shared/ruby/rawsensors_wrap.c'
+    src_files << $rawsensorsdir + '/ext/rawsensors/shared/src/rawsensors.c'
+
+    # build native part
+    build_extension('RawSensors', $arch, src_files)
+
+    # java part will be builded automatically (java files should be listed in ext_build.files ans ext. yml should be configured)
+
+  end
+end
+
+task :default => "build:all"

data/lib/extensions/rawsensors/ext/rawsensors/platform/android/ext_build.files

@@ -0,0 +1 @@
+ext/rawsensors/platform/android/src/com/rawsensors/RawSensors.java

data/lib/extensions/rawsensors/ext/rawsensors/platform/android/jni/src/rawsensors.cpp

@@ -0,0 +1,180 @@
+
+#include <rhodes.h>
+#include <android/log.h>
+
+#include "rubyext/WebView.h"
+
+#include "RhodesApp.h"
+
+#include "ruby/ext/rho/rhoruby.h"
+#include <string.h>
+#include <stdlib.h>
+
+#define logging_enable false
+
+static void logi(const char* text) {
+	if (logging_enable) __android_log_write(ANDROID_LOG_INFO, "RawSensors jni", text);
+}
+
+static void loge(const char* text) {
+	__android_log_write(ANDROID_LOG_INFO, "RawSensors jni ERROR : ", text);
+}
+
+
+extern "C" VALUE rawsensors_get_property(const char* property_name) {
+    logi("rawsensors_get_property() START");
+    JNIEnv *env = jnienv();
+    jclass cls = rho_find_class(env, "com/rawsensors/Rawsensors");
+    if (!cls) {
+        loge("rawsensors_get_property() class not found");
+        return rho_ruby_get_NIL();
+    }
+    jmethodID midGetType = env->GetStaticMethodID( cls, "getPropertyType", "(Ljava/lang/String;)I");
+    if (!midGetType) {
+        loge("rawsensors_get_property() method get type not found");
+        return rho_ruby_get_NIL();
+    }
+    jmethodID midGetStringValue = env->GetStaticMethodID( cls, "getStringProperty", "(Ljava/lang/String;)Ljava/lang/String;");
+    if (!midGetStringValue) {
+        loge("rawsensors_get_property() method get string not found");
+        return rho_ruby_get_NIL();
+    }
+    jmethodID midGetIntValue = env->GetStaticMethodID( cls, "getIntProperty", "(Ljava/lang/String;)I");
+    if (!midGetIntValue) {
+        loge("rawsensors_get_property() method get int not found");
+        return rho_ruby_get_NIL();
+    }
+
+    
+
+    // 1 - string
+	// 2 - bool
+	// 3 - int
+
+    jstring objStr = env->NewStringUTF(property_name);
+    int type = env->CallStaticIntMethod(cls, midGetType, objStr);
+    env->DeleteLocalRef(objStr);
+    
+    if (type == 1) {
+        jstring objStr = env->NewStringUTF(property_name);
+        jstring jstr = (jstring)env->CallStaticObjectMethod(cls, midGetStringValue, objStr);
+        env->DeleteLocalRef(objStr);
+        const char* buf = env->GetStringUTFChars(jstr,0);
+        VALUE result = rho_ruby_create_string(buf);
+        env->ReleaseStringUTFChars(jstr, buf);
+        logi("rawsensors_get_property() FINISH1");
+        return result;
+    }
+    if (type == 2) {
+        jstring objStr = env->NewStringUTF(property_name);
+        int value = env->CallStaticIntMethod(cls, midGetIntValue, objStr);
+        env->DeleteLocalRef(objStr);
+        VALUE result = rho_ruby_create_boolean(value);
+        logi("rawsensors_get_property() FINISH1");
+        return result;
+    }
+    if (type == 3) {
+        jstring objStr = env->NewStringUTF(property_name);
+        int value = env->CallStaticIntMethod(cls, midGetIntValue, objStr);
+        env->DeleteLocalRef(objStr);
+        VALUE result = rho_ruby_create_integer(value);
+        logi("rawsensors_get_property() FINISH3");
+        return result;
+    }
+    logi("rawsensors_get_property() FINISH");
+    return rho_ruby_get_NIL();
+}
+
+extern "C" void rawsensors_set_property(const char* property_name, const char* value) {
+    ///*
+    logi("rawsensors_set_property() START");
+    JNIEnv *env = jnienv();
+    jclass cls = rho_find_class(env, "com/rawsensors/Rawsensors");
+    if (!cls) {
+        loge("rawsensors_set_property() class not found");
+        return;
+    }
+    jmethodID mid = env->GetStaticMethodID( cls, "setProperty", "(Ljava/lang/String;Ljava/lang/String;)V");
+    if (!mid) {
+        loge("rawsensors_set_property() method not found");
+        return;
+    }
+    jstring objStr1 = env->NewStringUTF(property_name);
+    if (!objStr1) {
+        loge("rawsensors_set_property() can not make string1");
+        return;
+    }
+    jstring objStr2 = env->NewStringUTF(value);
+    if (!objStr2) {
+        loge("rawsensors_set_property() can not make string2");
+        return;
+    }
+    
+    env->CallStaticVoidMethod(cls, mid, objStr1, objStr2);
+    
+    env->DeleteLocalRef(objStr1);
+    env->DeleteLocalRef(objStr2);
+    logi("rawsensors_set_property() FINISH");
+    // */
+}
+
+extern "C" VALUE rawsensors_is_available(const char* sensor_name) {
+    ///*
+    logi("rawsensors_is_available() START");
+    JNIEnv *env = jnienv();
+    jclass cls = rho_find_class(env, "com/rawsensors/Rawsensors");
+    if (!cls) {
+        loge("rawsensors_is_available() class not found");
+        return rho_ruby_get_NIL();
+    }
+    jmethodID midGetIntValue = env->GetStaticMethodID( cls, "isAvailable", "(Ljava/lang/String;)I");
+    if (!midGetIntValue) {
+        loge("rawsensors_is_available() method not found");
+        return rho_ruby_get_NIL();
+    }
+    jstring objStr = env->NewStringUTF(sensor_name);
+    if (!objStr) {
+        loge("rawsensors_is_available() can not make string");
+        return rho_ruby_get_NIL();
+    }
+    int value = env->CallStaticIntMethod(cls, midGetIntValue, objStr);
+    env->DeleteLocalRef(objStr);
+    VALUE result = rho_ruby_create_boolean(value);
+    logi("rawsensors_is_available() FINISH");
+    return result;
+    // */
+}
+
+extern "C" void rawsensors_getSensorData() {
+    logi("rawsensors_getSensorData() START");
+    JNIEnv *env = jnienv();
+    jclass cls = rho_find_class(env, "com/rawsensors/Rawsensors");
+    if (!cls) {
+        loge("rawsensors_getSensorData() class not found");
+        return;
+    }
+    jmethodID mid = env->GetStaticMethodID( cls, "getSensorData", "()V");
+    if (!mid) {
+        loge("rawsensors_getSensorData() method not found");
+        return;
+    }
+    
+    env->CallStaticVoidMethod(cls, mid);
+    logi("rawsensors_getSensorData() FINISH");
+}
+
+extern "C" void JNICALL Java_com_rawsensors_Rawsensors_fireRhoCallback
+(JNIEnv *env, jclass, jstring js_callback_url, jstring js_body)
+{
+    logi("Java_com_rawsensors_Rawsensors_fireRhoCallback() START");
+    std::string url = rho_cast<std::string>(env, js_callback_url);
+    std::string body = rho_cast<std::string>(env, js_body);
+   
+    logi(url.c_str());
+    logi(body.c_str());
+    rho_net_request_with_data(url.c_str(), body.c_str());
+    logi("Java_com_rawsensors_Rawsensors_fireRhoCallback() FINISH");
+}
+
+
+

data/lib/extensions/rawsensors/ext/rawsensors/platform/android/src/com/rawsensors/Rawsensors.java

@@ -0,0 +1,355 @@
+package com.rawsensors;
+
+
+
+import com.rhomobile.rhodes.RhodesService;
+import com.rhomobile.rhodes.util.PerformOnUiThread;
+
+import android.content.Context;
+import android.hardware.SensorManager;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+
+
+
+public class Rawsensors {
+
+	public final static String RAWSENSORS_SERVICE_ACCELEROMETER = "accelerometer";
+	public final static String RAWSENSORS_SERVICE_MAGNETOMETER = "magnetometer";
+	public final static String RAWSENSORS_SERVICE_ALL = "all";
+	
+	public final static String RAWSENSORS_UPDATE_PERIOD = "minimumInterval";
+	public final static String RAWSENSORS_CALLBACK_URL = "sensorEvent";
+	
+	
+	private static Rawsensors ourInstance = null;
+	
+	public static Rawsensors getInstance() {
+		if (ourInstance == null) {
+			ourInstance = new Rawsensors();
+		}
+		return ourInstance;
+	}
+	
+	private class AccelerometerSensorEventListener implements SensorEventListener {
+		@Override
+		public void onAccuracyChanged(Sensor sensor, int accuracy) {
+		}
+
+		@Override
+		public void onSensorChanged(SensorEvent event) {
+			getInstance().onAccelerometer(event.values[0], event.values[1], event.values[2]);
+		}
+		
+	}
+	
+	private class MagnetometerSensorEventListener implements SensorEventListener {
+		@Override
+		public void onAccuracyChanged(Sensor sensor, int accuracy) {
+		}
+
+		@Override
+		public void onSensorChanged(SensorEvent event) {
+			getInstance().onMagnetometer(event.values[0], event.values[1], event.values[2]);
+		}
+		
+	}
+	
+	public Rawsensors() {
+		//PerformOnUiThread.exec(new Runnable() {
+		//	public void run() {	
+				mSensorManager = (SensorManager)RhodesService.getContext().getSystemService(Context.SENSOR_SERVICE);
+				mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+				mMagnetometer = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
+				mAccelerometerListener = new AccelerometerSensorEventListener();
+				mMagnetometerListener = new MagnetometerSensorEventListener();
+		//	}}, true);
+				
+		startHWUpdates();				
+	}
+
+	private double mAccelerometerX = 0.0;
+	private double mAccelerometerY = 0.0;
+	private double mAccelerometerZ = 0.0;
+
+	private double mMagnetometerX = 0.0;
+	private double mMagnetometerY = 0.0;
+	private double mMagnetometerZ = 0.0;
+	
+	private boolean mEnableAccelerometer = false;
+	private boolean mEnableMagnetometer = false;
+	private boolean mEnableAll = false;
+	
+	private int mUpdatePeriod = 1000;
+	
+	private String mCallbackURL = null;
+	
+	private SensorManager mSensorManager;
+    private Sensor mAccelerometer;
+    private Sensor mMagnetometer;
+    
+    private SensorEventListener mAccelerometerListener = null;
+    private SensorEventListener mMagnetometerListener = null;
+    
+    private Thread mUpdateThread = null;
+    
+    private final static String false_string = "false";
+    private final static String disabled_string = "disabled";
+	
+	public static void setProperty(String property_name, String value) {
+		try {
+		boolean need_resetup_thread = false;
+		if (RAWSENSORS_SERVICE_ACCELEROMETER.equals(property_name) ) {
+			need_resetup_thread = true;
+			if (false_string.equalsIgnoreCase(value) || disabled_string.equalsIgnoreCase(value)) {
+				getInstance().mEnableAccelerometer = false;
+			}
+			else {
+				getInstance().mEnableAccelerometer = true;
+			}
+		}
+		if (RAWSENSORS_SERVICE_MAGNETOMETER.equals(property_name) ) {
+			need_resetup_thread = true;
+			if (false_string.equalsIgnoreCase(value) || disabled_string.equalsIgnoreCase(value)) {
+				getInstance().mEnableMagnetometer = false;
+			}
+			else {
+				getInstance().mEnableMagnetometer = true;
+			}
+		}
+		if (RAWSENSORS_UPDATE_PERIOD.equals(property_name) ) {
+			need_resetup_thread = true;
+			int per = Integer.parseInt(value);
+			if (per < 200) {
+				per = 200;
+			}
+			getInstance().mUpdatePeriod = per;
+		}
+		if (RAWSENSORS_SERVICE_ALL.equals(property_name) ) {
+			need_resetup_thread = true;
+			if (false_string.equalsIgnoreCase(value) || disabled_string.equalsIgnoreCase(value)) {
+				//getInstance().mEnableAll = false;
+				getInstance().mEnableAccelerometer = false;
+				getInstance().mEnableMagnetometer = false;
+			}
+			else {
+				//getInstance().mEnableAll = true;
+				getInstance().mEnableAccelerometer = true;
+				getInstance().mEnableMagnetometer = true;
+			}
+		}
+		if (RAWSENSORS_CALLBACK_URL.equals(property_name) ) {
+			getInstance().mCallbackURL = value;
+		}
+		if (need_resetup_thread) {
+			getInstance().stopUpdates();
+			getInstance().startUpdates();
+		}
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	
+	// 1 - string
+	// 2 - bool
+	// 3 - int
+	public static int getPropertyType(String property_name) {
+		if (RAWSENSORS_SERVICE_ACCELEROMETER.equals(property_name) ) {
+			return 2;
+		}
+		if (RAWSENSORS_SERVICE_MAGNETOMETER.equals(property_name) ) {
+			return 2;
+		}
+		if (RAWSENSORS_UPDATE_PERIOD.equals(property_name) ) {
+			return 3;
+		}
+		if (RAWSENSORS_SERVICE_ALL.equals(property_name) ) {
+			return 2;
+		}
+		if (RAWSENSORS_CALLBACK_URL.equals(property_name) ) {
+			return 1;
+		}
+		return 1;
+	}
+	
+	public static int getIntProperty(String property_name) {
+		if (RAWSENSORS_SERVICE_ACCELEROMETER.equals(property_name) ) {
+			if (getInstance().mEnableAccelerometer) {
+				return 1;
+			}
+			return 0;
+		}
+		if (RAWSENSORS_SERVICE_MAGNETOMETER.equals(property_name) ) {
+			if (getInstance().mEnableMagnetometer) {
+				return 1;
+			}
+			return 0;
+		}
+		if (RAWSENSORS_UPDATE_PERIOD.equals(property_name) ) {
+			return getInstance().mUpdatePeriod;
+		}
+		if (RAWSENSORS_SERVICE_ALL.equals(property_name) ) {
+			if (getInstance().mEnableAccelerometer && getInstance().mEnableMagnetometer) {
+				return 1;
+			}
+			return 0;
+		}
+		return 0;
+	}
+
+	public static String getStringProperty(String property_name) {
+		if (RAWSENSORS_SERVICE_ACCELEROMETER.equals(property_name) ) {
+			if (getInstance().mEnableAccelerometer) {
+				return "true";
+			}
+			return "false";
+		}
+		if (RAWSENSORS_SERVICE_MAGNETOMETER.equals(property_name) ) {
+			if (getInstance().mEnableMagnetometer) {
+				return "true";
+			}
+			return "false";
+		}
+		if (RAWSENSORS_UPDATE_PERIOD.equals(property_name) ) {
+			return String.valueOf(getInstance().mUpdatePeriod);
+		}
+		if (RAWSENSORS_SERVICE_ALL.equals(property_name) ) {
+			if (getInstance().mEnableAll) {
+				return "true";
+			}
+			return "false";
+		}
+		if (RAWSENSORS_CALLBACK_URL.equals(property_name) ) {
+			return getInstance().mCallbackURL;
+		}
+		return null;
+	}
+	
+	
+	public static int isAvailable(String service_name) {
+		if (RAWSENSORS_SERVICE_ACCELEROMETER.equals(service_name)) {
+			if (getInstance().mAccelerometer != null) {
+				return 1;
+			}
+		}
+		if (RAWSENSORS_SERVICE_MAGNETOMETER.equals(service_name)) {
+			if (getInstance().mMagnetometer != null) {
+				return 1;
+			}
+		}
+		return 0;
+	}
+	
+    public void onAccelerometer(double x, double y, double z ){
+		mAccelerometerX = x;
+		mAccelerometerY = y;
+		mAccelerometerZ = z;
+    }
+	
+	public void onMagnetometer(double x, double y, double z) {
+		mMagnetometerX = x;
+		mMagnetometerY = y;
+		mMagnetometerZ = z;
+	}
+	
+	public void startHWUpdates() {
+		if (mAccelerometer != null) {
+			mSensorManager.unregisterListener(mAccelerometerListener, mAccelerometer);
+			mSensorManager.registerListener(mAccelerometerListener, mAccelerometer, SensorManager.SENSOR_DELAY_NORMAL);
+		}
+		if (mMagnetometer != null) {
+			mSensorManager.unregisterListener(mMagnetometerListener, mMagnetometer);
+			mSensorManager.registerListener(mMagnetometerListener, mMagnetometer, SensorManager.SENSOR_DELAY_NORMAL);
+		}
+	}
+	
+	public void stopHWUpdates() {
+		if ((mAccelerometer != null) ) {
+			mSensorManager.unregisterListener(mAccelerometerListener, mAccelerometer);
+		}
+		if ((mMagnetometer != null) ) {
+			mSensorManager.unregisterListener(mMagnetometerListener, mMagnetometer);
+		}
+	}
+	
+	public void startUpdates() {
+		
+		//PerformOnUiThread.exec(new Runnable() {
+		//	public void run() {	
+				if (mUpdateThread != null) {
+					//mUpdateThread.stop();
+					mUpdateThread.interrupt();
+					mUpdateThread = null;
+				}
+				mUpdateThread = new Thread() {
+					public void run() {
+						while (true) {
+							try {
+								getInstance().onUpdate();
+								sleep(getInstance().mUpdatePeriod);
+							} 
+							catch (InterruptedException e) {
+								return;
+							}
+							catch (Exception e) {
+								e.printStackTrace();
+							}
+						}
+					}
+				};
+				mUpdateThread.start();
+		//	}
+		//});
+	}
+	
+	public void stopUpdates() {
+		//PerformOnUiThread.exec(new Runnable() {
+		//	public void run() {	
+				if (mUpdateThread != null) {
+					//mUpdateThread.stop();
+					mUpdateThread.interrupt();
+					mUpdateThread = null;
+				}		
+		//	}});
+	}
+	
+	public void onUpdate() {
+		if ((mAccelerometer == null) || (!mEnableAccelerometer && !mEnableAll)) {
+			if ((mMagnetometer == null) || (!mEnableMagnetometer && !mEnableAll)) {
+				return;
+			}
+		}
+		StringBuffer strBody = new StringBuffer("&rho_callback=1&status=OK");
+		if (mEnableAccelerometer || mEnableAll) {
+			strBody = strBody.append("&accelerometerX=");
+			strBody = strBody.append(mAccelerometerX);
+			strBody = strBody.append("&accelerometerY=");
+			strBody = strBody.append(mAccelerometerY);
+			strBody = strBody.append("&accelerometerZ=");
+			strBody = strBody.append(mAccelerometerZ);
+		}
+		if (mEnableMagnetometer || mEnableAll) {
+			strBody = strBody.append("&magnetometerX=");
+			strBody = strBody.append(mMagnetometerX);
+			strBody = strBody.append("&magnetometerY=");
+			strBody = strBody.append(mMagnetometerY);
+			strBody = strBody.append("&magnetometerZ=");
+			strBody = strBody.append(mMagnetometerZ);
+		}
+		fireRhoCallback(mCallbackURL, strBody.toString());
+	}
+	
+	public static void getSensorData() {
+		PerformOnUiThread.exec( new Runnable() {
+			public void run() {
+				getInstance().onUpdate();
+			}
+		});
+	}
+	
+	
+	private static native void fireRhoCallback(String url, String body);
+
+}