rhodes 3.4.2 → 3.5.1.12

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

@@ -0,0 +1,97 @@
+require 'fileutils'
+
+
+USE_STLPORT = true
+
+
+def build_extension
+
+        require File.join($rhoroot, 'lib/build/jake.rb')
+
+	vsrclist = "RawSensors.files"
+
+        args = []
+        args << "-g"
+        args << "-d"
+        args << $tempdir
+        args << "-classpath"
+        args << $rubyvmjar
+        args << "-bootclasspath"
+        args << $jde + "/lib/net_rim_api.jar"
+        args << "-source"
+        args << "1.3"
+        args << "-target"
+        args << "1.3"
+        args << "-nowarn"
+        args << "@#{vsrclist}"
+        puts "\texecuting javac"
+        puts Jake.run($javac,args)
+        unless $? == 0
+          puts "Error compiling java code"
+          exit 1
+        end
+        $stdout.flush
+
+
+
+    	args2 = []
+	args2 << "cf"
+    	args2 << $targetdir+"/RawSensors.jar"
+    	#args2 << manifest
+	args2 << "-C"
+      	args2 << $tempdir
+      	args2 << "."
+
+
+        puts "\texecuting jar"
+        puts Jake.run($jar, args2)
+        unless $? == 0
+          puts "Error making JAR"
+          exit 1
+        end
+        $stdout.flush
+		
+
+
+end
+
+namespace "build" do
+  task :config do
+    $targetdir = ENV['TARGET_TEMP_DIR']
+    raise "TARGET_TEMP_DIR is not set" if $targetdir.nil?
+
+    $javac = ENV['JAVAC_EXE']
+    raise "JAVAC_EXE is not set" if $javac.nil?
+
+    $jar = ENV['JAR_EXE']
+    raise "JAR_EXE is not set" if $jar.nil?
+
+    $jde = ENV['JDE_HOME']
+    raise "JDE_HOME is not set" if $jde.nil?
+
+    $tempdir = ENV['TEMP_FILES_DIR']
+    raise "TEMP_FILES_DIR is not set" if $tempdir.nil?
+
+    $jde = ENV['JDE_HOME']
+    raise "JDE_HOME is not set" if $jde.nil?
+
+    $rubyvmjar = ENV['RUBYVM_JAR']
+    raise "RUBYVM_JAR is not set" if $rubyvmjar.nil?
+
+    $rhoroot = ENV['RHO_ROOT']
+    raise "RHO_ROOT is not set" if $rhoroot.nil?
+
+    $bbver = ENV['BB_SDK_VERSION']
+    raise "BB_SDK_VERSION is not set" if $bbver.nil?
+
+  end
+
+  task :all => :config do
+
+
+    build_extension	
+
+  end
+end
+
+task :default => "build:all"

data/lib/extensions/rawsensors/ext/rawsensors/platform/bb/Rawsensors.files

@@ -0,0 +1 @@
+src\com\rawsensors\RawSensors.java

data/lib/extensions/rawsensors/ext/rawsensors/platform/bb/rawsensors.jdp

@@ -0,0 +1,48 @@
+## RIM Java Development Environment
+# RIM Project file
+#
+# This file is generated and managed by BlackBerry developer tools.
+# It SHOULD NOT BE modified manually.
+#
+AddOn=0
+AlwaysBuild=0
+[AlxImports
+]
+AutoRestart=0
+[ClassProtection
+]
+[CustomBuildFiles
+]
+[CustomBuildRules
+]
+[DefFiles
+]
+[DependsOn
+]
+ExcludeFromBuildAll=0
+[Files
+src\com\rawsensors\RawSensors.java
+]
+HaveAlxImports=0
+HaveDefs=0
+HaveImports=0
+[Icons
+]
+[ImplicitRules
+]
+[Imports
+]
+Listing=0
+Options=-quiet
+OutputFileName=rawsensors
+[PackageProtection
+]
+RibbonPosition=0
+[RolloverIcons
+]
+RunOnStartup=0
+StartupTier=7
+SystemModule=0
+Type=0
+UserData=|src
+Version=1.51

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

@@ -0,0 +1,118 @@
+package com.rawsensors;
+
+import com.rho.RhodesApp;
+import com.rho.file.SimpleFile;
+import com.rho.net.IHttpConnection;
+import com.rho.net.RhoConnection;
+import com.rho.net.URI;
+
+import javax.microedition.io.Connector;
+import javax.microedition.io.file.FileConnection;
+import javax.microedition.lcdui.Image;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Hashtable;
+
+import com.rho.RhoClassFactory;
+import com.rho.RhoEmptyLogger;
+import com.rho.RhoLogger;
+import com.rho.RhoRuby;
+
+import com.xruby.runtime.builtin.ObjectFactory;
+import com.xruby.runtime.builtin.RubyString;
+import com.xruby.runtime.builtin.RubyFixnum;
+import com.xruby.runtime.builtin.RubyInteger;
+import com.xruby.runtime.lang.*;
+
+public class RawSensors implements Runnable {
+	
+	private static final RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() : 
+		new RhoLogger("RawSensors");
+
+	public static RubyModule RawSensorsModule;    
+
+	
+	public String doProcessString( String str ) {
+		return "<BB>" + str + "<BB>";
+	}
+
+	public int doCalcSumm( int x, int y ) {
+		return (x+y);
+	}
+
+	
+
+
+	public void run() {
+		  LOG.INFO("$$$ Register RawSensors Ruby class");
+   	  	  // register Ruby Module
+          RawSensorsModule = RubyAPI.defineModule("RawSensors");        
+          // register Ruby method
+          RawSensorsModule.getSingletonClass().defineMethod("native_process_string", new RubyOneArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
+				if ( arg0 instanceof RubyString )
+				{
+					String str = arg0.toString();
+					String result = doProcessString(str);
+					return ObjectFactory.createString(result);
+				}
+				else {
+					  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RawSensors.native_process_string: wrong argument type.Should be String");
+				}
+			}
+          });
+          RawSensorsModule.getSingletonClass().defineMethod("calc_summ", new RubyTwoArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg1, RubyValue arg2, RubyBlock block) {
+				try {
+					int x = 0;
+					int y = 0;
+					if (arg1 instanceof RubyFixnum) {
+						RubyFixnum rv = (RubyFixnum)arg1;
+						x = rv.toInt();
+					}
+					else {
+						if (arg1 instanceof RubyInteger) {
+							RubyInteger rv = (RubyInteger)arg1;
+							x = rv.toInt();
+						}
+						else {
+							if (arg1 instanceof RubySymbol) {
+								RubySymbol rv = (RubySymbol)arg1;
+								x = rv.toInt();
+							}
+							else {
+								  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RawSensors.calc_summ: wrong argument type.Should be Fixnum or Integer");
+							}
+						}
+					}
+					if (arg2 instanceof RubyFixnum) {
+						RubyFixnum rv = (RubyFixnum)arg2;
+						y = rv.toInt();
+					}
+					else {
+						if (arg2 instanceof RubyInteger) {
+							RubyInteger rv = (RubyInteger)arg2;
+							y = rv.toInt();
+						}
+						else {
+							if (arg2 instanceof RubySymbol) {
+								RubySymbol rv = (RubySymbol)arg2;
+								y = rv.toInt();
+							}
+							else {
+								  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RawSensors.calc_summ: wrong argument type.Should be Fixnum or Integer");
+							}
+						}
+					}
+					int res = doCalcSumm(x,y);
+					return ObjectFactory.createInteger(res);
+				} catch(Exception e) {
+					e.printStackTrace();
+					LOG.ERROR("RawSensors.calc_summ failed with exception", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+			}
+		});		
+	}
+
+}

data/lib/extensions/rawsensors/ext/rawsensors/platform/iphone/Classes/RawSensors.h

@@ -0,0 +1,66 @@
+
+#import <UIKit/UIKit.h>
+#import <Foundation/Foundation.h>
+#import <CoreMotion/CoreMotion.h>
+
+#include "ruby/ext/rho/rhoruby.h"
+
+#define RAW_SENSORS_SERVICE_ALL @"all"
+#define RAW_SENSORS_SERVICE_ACCELEROMETER @"accelerometer"
+#define RAW_SENSORS_SERVICE_MAGNETOMETER @"magnetometer"
+#define RAW_SENSORS_UPDATE_PERIOD @"minimumInterval"
+#define RAW_SENSORS_CALLBACK_URL @"sensorEvent"
+
+
+
+@interface RhoRawSensors: NSObject {
+    CMMotionManager *motionManager;
+    BOOL enableAccelerometer;
+    BOOL enableMagnetometer;
+    BOOL enableAll;
+    
+    NSTimer* timer;
+    
+    NSString* callbackURL;
+    
+    double acceleration_x;
+    double acceleration_y;
+    double acceleration_z;
+
+    double magnetometer_x;
+    double magnetometer_y;
+    double magnetometer_z;
+    
+    
+    int updatePeriod;
+}
+
+
++ (RhoRawSensors*) getInstance;
+
+- (VALUE) isAvailable:(NSString*)service_name;
+
+- (VALUE) getProperty:(NSString*)property_name;
+
+- (void) setProperty:(NSString*)property_name value:(NSString*)value;
+
+- (void) getSensorData;
+
+- (void) startPlatformUpdates;
+
+- (void) stopPlatformUpdates;
+
+- (void) onAccelerometerUpdate:(CMAccelerometerData*)accData error:(NSError*)error;
+
+- (void) onMagnetometerUpdate:(CMMagnetometerData*)magData error:(NSError*)error;
+
+- (void) onMotionUpdate:(CMDeviceMotion*)motion error:(NSError*)error;
+
+- (void) fireCallback;
+
+- (void) fireErrorCallback:(NSString*)message;
+
+- (void) onTimerFired:(NSTimer*)theTimer;
+
+
+@end

data/lib/extensions/rawsensors/ext/rawsensors/platform/iphone/Classes/RawSensors.m

@@ -0,0 +1,351 @@
+
+#import "RawSensors.h"
+
+#include "ruby/ext/rho/rhoruby.h"
+#import "common/RhodesApp.h"
+
+
+static RhoRawSensors* ourRhoSensors = nil;
+
+@implementation RhoRawSensors
+
++ (RhoRawSensors*) getInstance {
+    if (ourRhoSensors == nil) {
+        ourRhoSensors = [[RhoRawSensors alloc] init];
+    }
+    return ourRhoSensors;
+}
+
+- (void) initMotionManagerCommand {
+    motionManager = [[CMMotionManager alloc] init];
+}
+
+- (id) init {
+    [super init];
+    
+     [self performSelectorOnMainThread:@selector(initMotionManagerCommand) withObject:nil waitUntilDone:YES];
+    
+    enableAccelerometer = NO;
+    enableMagnetometer = NO;
+    enableAll = NO;
+    
+    timer = nil;
+    
+    acceleration_x = 0;
+    acceleration_y = 0;
+    acceleration_z = 0;
+    
+    magnetometer_x = 0;
+    magnetometer_y = 0;
+    magnetometer_z = 0;
+    
+    callbackURL = nil;
+    
+    
+    updatePeriod = 1000;
+    
+    
+    return self;
+}
+
+
+- (VALUE) isAvailable:(NSString*)service_name {
+    if ([RAW_SENSORS_SERVICE_ACCELEROMETER compare:service_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        if (motionManager.accelerometerAvailable) {
+            return rho_ruby_create_boolean(1);
+        }
+    }
+    if ([RAW_SENSORS_SERVICE_MAGNETOMETER compare:service_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        if (motionManager.deviceMotionAvailable && ([CMMotionManager availableAttitudeReferenceFrames] & CMAttitudeReferenceFrameXArbitraryCorrectedZVertical)) {
+            return rho_ruby_create_boolean(1);
+        }
+    }
+    return rho_ruby_create_boolean(0);
+}
+
+- (VALUE) getProperty:(NSString*)property_name {
+    if ([RAW_SENSORS_SERVICE_ACCELEROMETER compare:property_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        if (enableAccelerometer) {
+            return rho_ruby_create_boolean(1);
+        }
+        else {
+            return rho_ruby_create_boolean(0);
+        }
+    }
+    if ([RAW_SENSORS_SERVICE_MAGNETOMETER compare:property_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        if (enableMagnetometer) {
+            return rho_ruby_create_boolean(1);
+        }
+        else {
+            return rho_ruby_create_boolean(0);
+        }
+    }
+    if ([RAW_SENSORS_UPDATE_PERIOD compare:property_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        return rho_ruby_create_integer(updatePeriod);
+    }
+    if ([RAW_SENSORS_SERVICE_ALL compare:property_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        if (enableAccelerometer && enableMagnetometer) {
+            return rho_ruby_create_boolean(1);
+        }
+        else {
+            return rho_ruby_create_boolean(0);
+        }
+    }
+    if ([RAW_SENSORS_CALLBACK_URL compare:property_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        if (callbackURL != nil) {
+            return rho_ruby_create_string([callbackURL UTF8String]);
+        }
+    }
+    return rho_ruby_get_NIL();
+}
+
+- (void) setProperty:(NSString*)property_name value:(NSString*)value {
+    BOOL need_resetup_update = NO;
+    if ([RAW_SENSORS_SERVICE_ACCELEROMETER compare:property_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        need_resetup_update = YES;
+        if (([@"false" compare:value options:NSCaseInsensitiveSearch] == NSOrderedSame)
+            || ([@"disabled" compare:value options:NSCaseInsensitiveSearch] == NSOrderedSame)) {
+            enableAccelerometer = NO;
+        }
+        else {
+            enableAccelerometer = YES;
+        }
+    }
+    if ([RAW_SENSORS_SERVICE_MAGNETOMETER compare:property_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        need_resetup_update = YES;
+        if (([@"false" compare:value options:NSCaseInsensitiveSearch] == NSOrderedSame)
+            || ([@"disabled" compare:value options:NSCaseInsensitiveSearch] == NSOrderedSame)) {
+            enableMagnetometer = NO;
+        }
+        else {
+            enableMagnetometer = YES;
+        }
+    }
+    if ([RAW_SENSORS_SERVICE_ALL compare:property_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        need_resetup_update = YES;
+        if (([@"false" compare:value options:NSCaseInsensitiveSearch] == NSOrderedSame)
+            || ([@"disabled" compare:value options:NSCaseInsensitiveSearch] == NSOrderedSame)) {
+            //enableAll = NO;
+            enableAccelerometer = NO;
+            enableMagnetometer = NO;
+        }
+        else {
+            //enableAll = YES;
+            enableAccelerometer = YES;
+            enableMagnetometer = YES;
+        }
+    }
+    if ([RAW_SENSORS_UPDATE_PERIOD compare:property_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        
+        if (value != nil) {
+            int period = [value intValue];
+            if (period < 200) {
+                period = 200;
+            }
+            need_resetup_update = YES;
+            updatePeriod = period;
+        }
+    }
+    if ([RAW_SENSORS_CALLBACK_URL compare:property_name options:NSCaseInsensitiveSearch] == NSOrderedSame) {
+        if ((value != nil) /*&& ([value length] > 0)*/) {
+            callbackURL = value;
+        }
+    }
+    if (need_resetup_update) {
+        [self stopPlatformUpdates];
+        [self startPlatformUpdates];
+    }
+}
+
+- (void) getSensorData {
+    [self performSelectorOnMainThread:@selector(fireCallback) withObject:nil waitUntilDone:NO];
+    //[self fireCallback];
+}
+
+- (void) startPlatformUpdatesCommand {
+    BOOL real_updates = NO;
+    if (motionManager.accelerometerAvailable ) {
+        if (enableAccelerometer || enableAll) {
+            real_updates = YES;
+            motionManager.gyroUpdateInterval = 1.0/20.0;
+            
+            [motionManager startAccelerometerUpdatesToQueue:[NSOperationQueue currentQueue]
+                                                withHandler: ^(CMAccelerometerData* accData, NSError *error)
+             {
+                 [[RhoRawSensors getInstance] onAccelerometerUpdate:accData error:error];
+             }];
+        }
+    } else {
+        NSLog(@"No accelerometer on device.");
+        [self fireErrorCallback:@"No accelerometer on device."];
+        //[motionManager release];
+    }
+    if (motionManager.deviceMotionAvailable ) {
+        if (enableMagnetometer || enableAll) {
+            real_updates = YES;
+            motionManager.deviceMotionUpdateInterval = 1.0/20.0;
+            
+            //[motionManager startMagnetometerUpdatesToQueue:[NSOperationQueue currentQueue]
+            //                                   withHandler: ^(CMMagnetometerData* magData, NSError *error)
+            // {
+            //     [[RhoRawSensors getInstance] onMagnetometerUpdate:magData error:error];
+            // }];
+            
+            [motionManager startDeviceMotionUpdatesUsingReferenceFrame:CMAttitudeReferenceFrameXArbitraryCorrectedZVertical toQueue:[NSOperationQueue currentQueue] withHandler: ^(CMDeviceMotion *motion, NSError *error)
+             {
+                 [[RhoRawSensors getInstance] onMotionUpdate:motion error:error];
+             }];
+        }
+    } else {
+        NSLog(@"No magnetometer on device.");
+        [self fireErrorCallback:@"No magnetometer on device."];
+        //[motionManager release];
+    }
+    if (timer != nil) {
+        [timer invalidate];
+        timer = nil;
+    }
+    if (real_updates) {
+        timer = [NSTimer scheduledTimerWithTimeInterval:(((float)updatePeriod)/1000.0) target:self selector:@selector(onTimerFired:) userInfo:nil repeats:YES];
+    }
+}
+
+- (void) startPlatformUpdates {
+    [self performSelectorOnMainThread:@selector(startPlatformUpdatesCommand) withObject:nil waitUntilDone:NO];
+}
+
+- (void) stopPlatformUpdatesCommand {
+    if (timer != nil) {
+        [timer invalidate];
+        timer = nil;
+    }
+    [motionManager stopAccelerometerUpdates];
+    [motionManager stopDeviceMotionUpdates];
+    //acceleration_x = 0;
+    //acceleration_y = 0;
+    //acceleration_z = 0;
+    
+    //magnetometer_x = 0;
+    //magnetometer_y = 0;
+    //magnetometer_z = 0;
+}
+
+- (void) stopPlatformUpdates {
+    [self performSelectorOnMainThread:@selector(stopPlatformUpdatesCommand) withObject:nil waitUntilDone:NO];
+}
+
+- (void) onAccelerometerUpdate:(CMAccelerometerData*)accData error:(NSError*)error {
+    acceleration_x = accData.acceleration.x * 9.81;
+    acceleration_y = accData.acceleration.y * 9.81;
+    acceleration_z = accData.acceleration.z * 9.81;
+}
+
+- (void) onMagnetometerUpdate:(CMMagnetometerData*)magData error:(NSError*)error {
+    // this is RAW data with device filed include
+    //magnetometer_x = magData.magneticField.x;
+    //magnetometer_y = magData.magneticField.y;
+    //magnetometer_z = magData.magneticField.z;
+}
+
+- (void) onMotionUpdate:(CMDeviceMotion*)motion error:(NSError*)error {
+    magnetometer_x = motionManager.deviceMotion.magneticField.field.x;// motion.magneticField.field.x;
+    magnetometer_y = motionManager.deviceMotion.magneticField.field.y;//motion.magneticField.field.y;
+    magnetometer_z = motionManager.deviceMotion.magneticField.field.z;//motion.magneticField.field.z;
+    //magnetometer_x = motion.magneticField.field.x;
+    //magnetometer_y = motion.magneticField.field.y;
+    //magnetometer_z = motion.magneticField.field.z;
+}
+
+
+
+- (void) fireCallback {
+    if (callbackURL == nil) {
+        return;
+    }
+    if ([callbackURL length] <= 0) {
+        return;
+    }
+    if (!enableAccelerometer && !enableMagnetometer && !enableAll) {
+        return;
+    }
+	NSString* strBody = @"&rho_callback=1&status=OK";
+    
+    if (enableAccelerometer || enableAll) {
+        strBody = [strBody stringByAppendingString:@"&accelerometerX="];
+        strBody = [strBody stringByAppendingString:[NSString stringWithFormat:@"%f",acceleration_x]];
+        strBody = [strBody stringByAppendingString:@"&accelerometerY="];
+        strBody = [strBody stringByAppendingString:[NSString stringWithFormat:@"%f",acceleration_y]];
+        strBody = [strBody stringByAppendingString:@"&accelerometerZ="];
+        strBody = [strBody stringByAppendingString:[NSString stringWithFormat:@"%f",acceleration_z]];
+    }
+    if (enableMagnetometer || enableAll) {
+        strBody = [strBody stringByAppendingString:@"&magnetometerX="];
+        strBody = [strBody stringByAppendingString:[NSString stringWithFormat:@"%f",magnetometer_x]];
+        strBody = [strBody stringByAppendingString:@"&magnetometerY="];
+        strBody = [strBody stringByAppendingString:[NSString stringWithFormat:@"%f",magnetometer_y]];
+        strBody = [strBody stringByAppendingString:@"&magnetometerZ="];
+        strBody = [strBody stringByAppendingString:[NSString stringWithFormat:@"%f",magnetometer_z]];
+    }
+	const char* cb = [callbackURL UTF8String];
+	const char* b = [strBody UTF8String];
+    char* norm_url = rho_http_normalizeurl(cb);
+    
+	rho_net_request_with_data(rho_http_normalizeurl(cb), b);
+    
+    rho_http_free(norm_url);
+    
+}
+
+- (void) fireErrorCallback:(NSString*)message {
+    if (callbackURL == nil) {
+        return;
+    }
+    if ([callbackURL length] <= 0) {
+        return;
+    }
+	NSString* strBody = @"&rho_callback=1&status=ERROR";
+    
+    strBody = [strBody stringByAppendingString:@"&message="];
+    strBody = [strBody stringByAppendingString:message];
+    
+	const char* cb = [callbackURL UTF8String];
+	const char* b = [strBody UTF8String];
+    char* norm_url = rho_http_normalizeurl(cb);
+    
+	rho_net_request_with_data(rho_http_normalizeurl(cb), b);
+    
+    rho_http_free(norm_url);
+    
+}
+
+
+- (void) onTimerFired:(NSTimer*)theTimer {
+    if (enableAll || enableAccelerometer || enableMagnetometer) {
+        [self fireCallback];
+    }
+}
+
+@end
+
+
+
+
+
+
+VALUE rawsensors_get_property(const char* property_name) {
+    VALUE result = [[RhoRawSensors getInstance] getProperty:[NSString stringWithUTF8String:property_name]];
+    return result;
+}
+
+void rawsensors_set_property(const char* property_name, const char* value) {
+    [[RhoRawSensors getInstance] setProperty:[NSString stringWithUTF8String:property_name] value:[NSString stringWithUTF8String:value]];
+}
+
+VALUE rawsensors_is_available(const char* sensor_name) {
+    VALUE result = [[RhoRawSensors getInstance] isAvailable:[NSString stringWithUTF8String:sensor_name]];
+    return result;
+}
+
+void rawsensors_getSensorData() {
+    [[RhoRawSensors getInstance] getSensorData];
+}