rhodes 3.0.0 → 3.0.1.beta.2

data/doc/rhom.txt

@@ -224,10 +224,12 @@ Below is a full list of options available to fixed schema models:
 	  property :mycustomproperty, 'hello'
 	end
 
-### Fixed Schema Data Migrations
-When the application starts the first time after an update, the database will be (re)created if the `app_db_version` in `rhoconfig.txt` is different from what existed before.  If the database is recreated, the existing database is removed along with all data.  
+## Data Migrations
+To clean all client data at startup - change `app_db_version` in `rhoconfig.txt`.
+This scenario will work for Property Bag and Fixed Schema models
 
-For this scenario, Rhom provides an application hook to migrate the data manually, overriding the default behavior which deletes the data.  You can also use this hook to run business logic related to updating the database.  For example, your application may want to display a customized alert notifying the user that a migration is in progress and it may take a few moments.
+### Fixed Schema Data Migrations
+Rhom provides an application hook to migrate the data manually, overriding the default behavior which deletes the data.  You can also use this hook to run business logic related to updating the database.  For example, your application may want to display a customized alert notifying the user that a migration is in progress and it may take a few moments.
 
 To use this hook, first we need to track the `:schema_version` in our model:
 
@@ -597,11 +599,11 @@ Returns 1 if last sync was successful, 0 if it failed.
 	@source.last_sync_success 
 	  #=> 1
 
-### `distinct_object`
+### `distinct_objects`
 Number of records for this source.
 
 	:::ruby
-	@source.distinct_object
+	@source.distinct_objects
 	  #=> 837
 
 ## Resetting the Database

data/doc/simulator.txt

@@ -0,0 +1,116 @@
+# Using RhoSimulator
+
+RhoSimulator allows to [run](#run-application-in-rhosimulator) Rhodes applications without lengthy build process and to [debug](#debugging-with-rhostudio) them in [RhoStudio](../rhostudio.tutorial). Currently RhoSimulator works on <b>Windows</b> only.
+
+## Install RhoSimulator
+
+If you have [Rhodes gem](install#rhodes-gem), then RhoSimulator is installed already.
+
+If you would like to run RhoSimulator without Rhodes gem, [download it](http://rhosimulator.s3.amazonaws.com/RhoSimulator.zip), unzip and specify path to `rhosimulator.exe` at `rhodes/rhobuild.yml`:
+
+        env: 
+           paths:    
+              rhosimulator: <RhoSimulator folder>
+
+Alternatively you may [build](#build-rhosimulator) your own customized version of RhoSimulator as described [below](#build-rhosimulator).
+
+## Run application in RhoSimulator
+
+To run application in RhoSimulator just run in rhodes or application folder:
+
+    rake run:win32:rhosimulator
+
+If you modified Rhodes application sources, just press 'Refresh' in RhoSimulator to reload application, i.e. generally no RhoSimulator restart is required.
+The restart of RhoSimulator is required only if a model was added/modified or some code was added to the AppApplication class.
+
+## Debugging with RhoStudio
+
+### Prerequisites
+
+* Install [RhoStudio](../rhostudio.tutorial)
+* Install [RhoSimulator](#install-rhosimulator)
+* Ensure your application is configured properly and successfully [runs in RhoSimulator](#run-application-in-rhosimulator) (from command line as described above)
+
+### Starting debug session in RhoStudio
+
+* Select Run » Debug Configurations... from top menu
+* Find 'Rhodes Application' section on the left and add new (or modify existing) configuration
+* On 'Common setting' tab select a project by clicking 'Browse...' button next to 'Project name:'
+* Select 'Rho simulator' as the platform
+* Click 'Apply' and then 'Debug'
+
+### Debug capabilities
+
+In present version of RhoStudio you may:
+
+* Set breakpoints in Ruby code (.rb files)
+* Watch variable values (global, local, class and instance) - currently auto-watch list is displayed in Expressions window
+* View application log in Console window
+
+## Build RhoSimulator
+
+If you use custom native extensions, then running and debugging your applications in RhoSimulator requires a custom build.
+Follow these instructions to build your own customized version of RhoSimulator.
+
+### Preliminary steps
+
+* Currently only <b>Visual Studio 2005 Service Pack 1</b> is supported
+* Follow [Build for Windows - Prerequisites](build#build-for-windows), but do not install the Rhodes gem since you're going to use Rhodes SDK source.
+* Get the `rhodes` source (if haven't done it already) as described [here](build#setup-rhodes-source-code). Don't forget to add the `bin` folder to your path, run `rhodes-setup` and update Rhodes SDK path in `build.yml` at your application root folder.
+* First build the Qt libraries for VS 2005:
+    * Download the Qt source:
+        * Go to [http://qt.nokia.com/downloads](http://qt.nokia.com/downloads)
+        * Choose the open source LGPL version
+        * Under the Framework Only section choose Qt libraries for Windows (VS 2008)
+        * Cancel automatically started download, and download the [source code](http://get.qt.nokia.com/qt/source/qt-everywhere-opensource-src-4.7.3.zip)
+        * Extract the downloaded archive, e.g. into `C:\Qt\4.7.3-msvc2005`
+    * Prepare to build the OpenSSL library:
+        * Download [v0.9 source code](http://www.openssl.org/source/openssl-0.9.8r.tar.gz) from [www.openssl.org](http://www.openssl.org/) and extract the downloaded archive, e.g. into `C:\Qt\openssl-0.9.8r`
+        * Install Perl interpreter (if it's not installed yet), e.g. [ActiveState Perl](http://www.activestate.com/activeperl)
+    * Open Control Panel » System » Advanced system settings » Environment Variables and then:
+        * Create new system variable `QTDIR` = `C:\Qt\4.7.3-msvc2005`
+        * Add to the `PATH` variable: `C:\Qt\4.7.3-msvc2005\bin;C:\Qt\openssl-0.9.8r\bin` (it doesn't matter that `C:\Qt\openssl-0.9.8r\bin` folder does not exist yet)
+        * Either close all command prompts and Visual Studio instances, or reboot the computer so the new settings take effect.
+    * Open Visual Studio 2005 Command Prompt. This is accomplished using Start » All Programs » Microsoft Visual Studio 2005 » Visual Studio Tools » Visual Studio 2005 Command Prompt. Run in Visual Studio 2005 Command Prompt:
+
+			> vcvarsall.bat x86
+			> C:
+
+    * To build OpenSSL library run in the same command prompt:
+
+			> cd \Qt\openssl-0.9.8r
+			> perl Configure VC-WIN32 --prefix=C:/Qt/openssl-0.9.8r
+			> ms\do_masm
+			> nmake -f ms\ntdll.mak
+			> nmake -f ms\ntdll.mak install
+			> nmake -f ms\ntdll.mak clean
+
+    * To build Qt library run in the same command prompt:
+
+			> cd \Qt\4.7.3-msvc2005
+			> configure -opensource -platform win32-msvc2005
+			  -nomake examples -nomake demos -nomake docs
+			  -qt-libpng -qt-libjpeg -qt-libtiff -qt-gif -qt-libmng
+			  -openssl-linked -I C:/Qt/openssl-0.9.8r/include
+			  -L C:/Qt/openssl-0.9.8r/lib
+			> nmake
+			> nmake clean
+
+      Be aware that it will take a while to build the Qt libraries from sources (maybe few hours or so). Particularly the `configure` command may run for a few minutes, and the `nmake` command may run for a few hours.
+    * After the build process is completed exit Visual Studio 2005 Command Prompt
+
+### Build with rake command:
+
+	rake build:win32:rhosimulator
+
+To run Rhodes applications in custom built RhoSimulator, please ensure that no `env:` » `paths:` » `rhosimulator:` line is present at your `rhobuild.yml` (if present, remove that line).
+
+### Build in Visual Studio 2005:
+
+* Open the solution:
+  `C:\Rhomobile\rhodes\platform\wm\rhodes\rhodes.vcproj`
+* Build solution for the configuration `EmulatorRelease|Win32`
+* Specify the path to custom built RhoSimulator at `rhobuild.yml`:
+        env: 
+          paths:    
+            rhosimulator: platform/wm/bin/Win32/rhodes/EmulatorRelease

data/doc/ui.txt

@@ -540,7 +540,7 @@ Each tabbar item defined in the above sample defines following tab elements:
 * :reload => true - Optional argument which tells rhodes to reload the tab's :action, defaults to false
 * :selected_color => 0xFFFF00 - Optional parameter for change selected color of this tabs (if you use it on Android - you should defined it for all tabs! and also define :background_color for TabBar!)
 * :disabled => true - Optional parameter for disable this tab
-* :web_bkg_color = > int hex value (like HTML color) - background color for tab (use when your app bkg is not white for remove blink during switch tabs)
+* :web_bkg_color = > int hex value (0x7F7F7F for example) - background color for tab (use when your app bkg is not white for remove blink during switch tabs)
 * :use_current_view_for_tab => true - Optional argument which tells rhodes to smooth transfer WebView from current view into this Tab and make this Tab active. Defaults to false. Only one Tab can have this parameter!
 
 

data/lib/build/jake.rb

@@ -38,7 +38,7 @@ class Jake
 
   def self.get_absolute(path)
     return File.expand_path(path) if File.exists?(path)
-    currentdir = pwd
+    currentdir = Dir.pwd()
     
     path = currentdir + "/" + path
   
@@ -210,13 +210,13 @@ class Jake
 
   	wd = options[:directory]
   	if not wd.nil?
-      currentdir = pwd()
+      currentdir = Dir.pwd()
       chdir wd
     end
 
     cmdstr = argv.map { |x| x =~ / |\|/ ? '"' + x + '"' : x }.join(' ')
 
-    puts "PWD: " + pwd
+    puts "PWD: " + Dir.pwd()
     puts "CMD: " + cmdstr
     $stdout.flush
 
@@ -278,7 +278,7 @@ class Jake
 
       p = Pathname.new(src)
     src = p.realpath
-    currentdir = pwd()
+    currentdir = Dir.pwd()
     src = src.to_s.gsub(/"/,"")
   
     args = Array.new
@@ -344,7 +344,7 @@ class Jake
     javabin = $config["env"]["paths"]["java"]
     cmd = jdehome + "/bin/rapc.exe"
     
-    currentdir = pwd()
+    currentdir = Dir.pwd()
   
   
     chdir destdir

data/lib/extensions/debugger/debugger.rb

@@ -1,6 +1,9 @@
 require 'uri'
 require 'timeout'
 
+DEBUGGER_STEP_TYPE = ['STEP','STOVER','STRET','SUSP']
+DEBUGGER_STEP_COMMENT = ['Stepped into','Stepped over','Stepped return','Suspended']
+
 def debug_read_cmd(io,wait)
   begin
     if wait
@@ -59,7 +62,14 @@ def get_variables(scope)
     vars = eval(prefix + cmd, $_binding)
     $_s.write("VSTART:#{vartype}\n")
     vars.each do |v|
-      $_s.write("V:#{vartype}:#{v}:#{eval(v,$_binding).inspect}\n")
+      if v !~ /^\$(=|KCODE)$/
+        begin
+          result = eval(v,$_binding).inspect
+        rescue Exception => exc
+          result = "#{$!}".inspect
+        end
+        $_s.write("V:#{vartype}:#{v}:#{result}\n")
+      end
     end
     $_s.write("VEND:#{vartype}\n")
   rescue
@@ -67,7 +77,7 @@ def get_variables(scope)
 end
 
 def log_command(cmd)
-  puts "[Debugger] Received command: #{cmd}"
+  # puts "[Debugger] Received command: #{cmd}"
 end
 
 def debug_handle_cmd(inline)
@@ -108,35 +118,44 @@ def debug_handle_cmd(inline)
       processed = true
     elsif inline and (cmd =~ /^STEPOVER/)
       log_command(cmd)
-      $_step = true
+      $_step = 2
       $_step_level = $_call_stack
+      $_resumed = true
       wait = false
       puts "[Debugger] Step over"
       processed = true
     elsif inline and (cmd =~ /^STEPRET/)
       log_command(cmd)
-      $_step = true
-      $_step_level = $_call_stack-1
+      if $_call_stack < 1
+        $_step = 0
+        comment = ' (continue)'
+      else
+        $_step = 3
+        $_step_level = $_call_stack-1;
+        comment = ''
+      end
+      $_resumed = true
       wait = false
-      puts "[Debugger] Step return"
+      puts "[Debugger] Step return" + comment
       processed = true
     elsif inline and (cmd =~ /^STEP/)
       log_command(cmd)
-      $_step = true
+      $_step = 1
       $_step_level = -1
+      $_resumed = true
       wait = false
       puts "[Debugger] Step into"
       processed = true
     elsif inline and (cmd =~ /^CONT/)
       log_command(cmd)
       wait = false
-      $_step = false
+      $_step = 0
       $_resumed = true
       puts "[Debugger] Resuming"
       processed = true
     elsif cmd =~ /^SUSP/
       log_command(cmd)
-      $_step = true
+      $_step = 4
       $_step_level = -1
       wait = true
       puts "[Debugger] Suspend"
@@ -172,36 +191,44 @@ $_tracefunc = lambda{|event, file, line, id, bind, classname|
   $_binding = bind;
   $_classname = classname;
   $_methodname = id;
-  if event =~ /^line/
-
-    unhandled = true
-    step_stop = $_step and (($_step_level < 0) or ($_call_stack <= $_step_level))
-    if (step_stop or ($_breakpoints_enabled and (not $_breakpoint.empty?)))
-      filename = file.sub(/^(.*?[\\\/]|)app[\\\/](.*)$/,'\\2')
-      ln = line.to_i.to_s
-      if (step_stop or ($_breakpoints_enabled and ($_breakpoint.has_key?(filename + ':' + ln))))
-        fn = filename.gsub(/:/, '|')
-        cl = classname.to_s.gsub(/:/,'#')
-        $_s.write((step_stop ? "STEP" : "BP") + ":#{fn}:#{ln}:#{cl}:#{id}\n")
-        puts "[Debugger] " + (step_stop ? "Stop" : "Breakpoint") + " in #{fn} at #{ln}"
+  file = file.to_s.gsub('\\', '/')
+  if file[0, $_app_path.length] == $_app_path
+    if event =~ /^line/
 
-        $_wait = true
-        while $_wait
-          while debug_handle_cmd(true) do end
-          sleep if $_wait
+      unhandled = true
+      step_stop = ($_step > 0) and (($_step_level < 0) or ($_call_stack <= $_step_level))
+      if (step_stop or ($_breakpoints_enabled and (not $_breakpoint.empty?)))
+        filename = file[$_app_path.length, file.length-$_app_path.length]
+        ln = line.to_i.to_s
+        if (step_stop or ($_breakpoints_enabled and ($_breakpoint.has_key?(filename + ':' + ln))))
+          fn = filename.gsub(/:/, '|')
+          cl = classname.to_s.gsub(/:/,'#')
+          $_s.write((step_stop ? DEBUGGER_STEP_TYPE[$_step-1] : "BP") + ":#{fn}:#{ln}:#{cl}:#{id}\n")
+          puts "[Debugger] " + (step_stop ? DEBUGGER_STEP_COMMENT[$_step-1] : "Breakpoint") + " in #{fn} at #{ln}"
+          $_step = 0
+          $_step_level = -1
+
+          $_wait = true
+          while $_wait
+            while debug_handle_cmd(true) do end
+            if System::get_property('main_window_closed')
+              $_wait = false
+            end
+            sleep if $_wait
+          end
+          unhandled = false
         end
-        unhandled = false
       end
-    end
 
-    if unhandled
-      debug_handle_cmd(true)
-    end
+      if unhandled
+        debug_handle_cmd(true)
+      end
 
-  elsif event =~ /^call/
-    $_call_stack += 1
-  elsif event =~ /^return/
-    $_call_stack -= 1
+    elsif event =~ /^call/
+      $_call_stack += 1
+    elsif event =~ /^return/
+      $_call_stack -= 1
+    end
   end
 
   if $_resumed
@@ -224,11 +251,12 @@ begin
 
   $_breakpoint = Hash.new
   $_breakpoints_enabled = true
-  $_step = false
+  $_step = 0
   $_step_level = -1
   $_call_stack = 0
   $_resumed = false
   $_cmd = ""
+  $_app_path = File.join(Rho::RhoApplication::get_base_app_path(), 'app/').gsub('\\', '/')
 
   at_exit {
     $_s.write("QUIT\n") if (not $_s.nil?)

data/lib/extensions/nfc/ext/nfc/platform/android/AndroidManifest.xml

@@ -10,15 +10,18 @@
     <uses-feature android:name="android.hardware.nfc" android:required="false" />
 
     <application>
-        
+
         <activity  android:name="com.rhomobile.nfc.NfcActivity">
             <intent-filter>
-                <action android:name="android.nfc.action.TAG_DISCOVERED"/>
                 <category android:name="android.intent.category.DEFAULT"/>
+                <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
+            </intent-filter>
+
+            <intent-filter>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <action android:name="android.nfc.action.TAG_DISCOVERED"/>
             </intent-filter>
-        </activity>
 
-        <activity  android:name="com.rhomobile.nfc.NfcTechActivity">
             <intent-filter>
                 <category android:name="android.intent.category.DEFAULT"/>
                 <action android:name="android.nfc.action.TECH_DISCOVERED" />
@@ -27,9 +30,8 @@
             <meta-data android:name="android.nfc.action.TECH_DISCOVERED"
                 android:resource="@xml/filter_nfc"
             />
-
         </activity>
-        
+
     </application>
     
     <uses-permission android:name="android.permission.NFC" />

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

@@ -18,141 +18,317 @@
 
 
 
-
 #define logging_enable false
 
-
 void logi(const char* text) {
 	if (logging_enable) __android_log_write(ANDROID_LOG_INFO, "NFC jni", text);
 } 
 
+void loge(const char* text) {
+	__android_log_write(ANDROID_LOG_INFO, "NFC jni ERROR : ", text);
+} 
 
-extern "C" void rho_nfc_set_callback(const char* callback_url) {
-	JNIEnv *env = jnienv();
-	jclass cls = rho_find_class(env, "com/rhomobile/nfc/Nfc");
-	if (!cls) return;
-	jmethodID mid = env->GetStaticMethodID( cls, "setCallback", "(Ljava/lang/String;)V");
-	if (!mid) return;
-	jstring objCallback = env->NewStringUTF(callback_url);
-	env->CallStaticVoidMethod(cls, mid, objCallback);
-	env->DeleteLocalRef(objCallback);
-}
 
-extern "C" void rho_nfc_enable(int enable) {
-	JNIEnv *env = jnienv();
-	jclass cls = rho_find_class(env, "com/rhomobile/nfc/Nfc");
-	if (!cls) return;
-	jmethodID mid = env->GetStaticMethodID( cls, "setEnable", "(I)V");
-	if (!mid) return;
-	env->CallStaticVoidMethod(cls, mid, enable);
-}
+class CNfcJavaClass {
+public:
+    CNfcJavaClass() {
+        JNIEnv *env = jnienv();
+        mNfcClass = rho_find_class(env, "com/rhomobile/nfc/Nfc");
+    }
+
+    ~CNfcJavaClass() {
+        JNIEnv *env = jnienv();
+        env->DeleteLocalRef(mNfcClass);
+    }
+    
+    jclass get() {
+        return mNfcClass;
+    }
+    
+private:
+    jclass mNfcClass;
+};
 
-extern "C" int rho_nfc_is_enabled(void) {
-	JNIEnv *env = jnienv();
-	jclass cls = rho_find_class(env, "com/rhomobile/nfc/Nfc");
-	if (!cls) return 0;
-	jmethodID mid = env->GetStaticMethodID( cls, "isEnabled", "()I");
-	if (!mid) return 0;
-	return env->CallStaticIntMethod(cls, mid);
-}
 
-extern "C" int rho_nfc_is_supported(void) {
-	JNIEnv *env = jnienv();
-	jclass cls = rho_find_class(env, "com/rhomobile/nfc/Nfc");
-	if (!cls) return 0;
-	jmethodID mid = env->GetStaticMethodID( cls, "isSupported", "()I");
-	if (!mid) return 0;
-	return env->CallStaticIntMethod(cls, mid);
-}
+class CRubyString {
+public:
+    
+    CRubyString(const char* str) {
+        mStr = str;
+        mJavaObject = NULL;
+        mEnv = NULL;
+    }
+    
+    ~CRubyString() {
+        if (mJavaObject != NULL) {
+            mEnv->DeleteLocalRef(mJavaObject);
+        }
+    }
+    
+    jstring makeJavaString(JNIEnv* env) {
+        mEnv = env;
+        mJavaObject = env->NewStringUTF(mStr);
+        return mJavaObject;
+    }
+    
+private:    
+    jstring mJavaObject;
+    JNIEnv* mEnv;
+    const char* mStr;
+};
 
+class CRubyByteArray {
+public:
+    CRubyByteArray(VALUE array) {
+        if (array != 0) {
+            mSize = rho_ruby_unpack_byte_array(array, 0, 0);
+            mBuf = new unsigned char[mSize];
+            rho_ruby_unpack_byte_array(array, mBuf, mSize);
+        }
+        else {
+            mBuf = NULL;
+            mSize = 0;
+        }
+        mJavaObject = NULL;
+    }
+    
+    jbyteArray makeJavaByteArray(JNIEnv* env) {
+        if (mBuf != NULL) {
+            mEnv = env;
+            mJavaObject = (jbyteArray)env->NewByteArray(mSize);
+            jbyte* buf_p = env->GetByteArrayElements(mJavaObject, 0);
+            int i;
+            for (i = 0; i < mSize; i++) {
+                buf_p[i] = mBuf[i];
+            }
+            env->ReleaseByteArrayElements(mJavaObject, buf_p, 0);
+        }
+        return mJavaObject;
+    }
+    
+    ~CRubyByteArray() {
+        if (mJavaObject != NULL) {
+            mEnv->DeleteLocalRef(mJavaObject);
+        }
+        if (mBuf != NULL) {
+            delete mBuf;
+        }
+    }
+    
+private:
+    unsigned char* mBuf;
+    int mSize;
+    jbyteArray mJavaObject;
+    JNIEnv* mEnv;
+};
 
 
-extern "C" void rho_nfc_set_tech_callback(const char* callback_url) {
-	JNIEnv *env = jnienv();
-	jclass cls = rho_find_class(env, "com/rhomobile/nfc/Nfc");
-	if (!cls) return;
-	jmethodID mid = env->GetStaticMethodID( cls, "setTechCallback", "(Ljava/lang/String;)V");
-	if (!mid) return;
-	jstring objCallback = env->NewStringUTF(callback_url);
-	env->CallStaticVoidMethod(cls, mid, objCallback);
-	env->DeleteLocalRef(objCallback);
-}
+class CNFCString {
+public:
+	CNFCString(JNIEnv* env, jobject jo_string) {
+        mBuf = NULL;
+        if (jo_string != NULL) {
+            const char* msg = env->GetStringUTFChars((jstring)jo_string,0);
+            mSize = strlen(msg);
+            mBuf = new char[mSize+1];
+            strcpy(mBuf, msg);
+            env->ReleaseStringUTFChars((jstring)jo_string, msg);
+        }
+	}
 
-extern "C" void rho_nfc_set_listen_tech_list(VALUE tech_list) {
+	virtual ~CNFCString() {
+        if (mBuf != NULL) {
+            delete mBuf;
+        }
+	}
 
-}
+    VALUE makeVALUE() {
+        if (mBuf != NULL) {
+            return rho_ruby_create_string((const char*)mBuf);
+        }
+        else  {
+            return rho_ruby_get_NIL();
+        }
+        
+    }
+    
+    
+	char* mBuf;
+	int mSize;
+};
 
-extern "C" VALUE rho_nfc_get_tech_list() {
-      return rho_ruby_get_NIL();
-}
 
-extern "C" void rho_nfc_tech_connect(const char* name) {
 
-}
+class CNFCByteArray {
+public:
+	CNFCByteArray(JNIEnv* env, jobject jo_bytearray) {
+        logi("Construct ByteArray from java object START");
+        mBuf = NULL;
+        if (jo_bytearray != NULL) {
+            mSize = env->GetArrayLength((jbyteArray)jo_bytearray);
+            if (mSize > 0) {
+                if (logging_enable) {
+                    char msg[128];
+                    sprintf(msg, "    array size = %d", mSize);
+                    logi(msg);
+                }
+                mBuf = new unsigned char[mSize];
+                unsigned char* jarray_buf = (unsigned char*)env->GetByteArrayElements((jbyteArray)jo_bytearray, 0);
+                int i;
+                for (i = 0; i < mSize; i++) {
+                    mBuf[i] = jarray_buf[i];
+                }
+                env->ReleaseByteArrayElements((jbyteArray)jo_bytearray, (jbyte*)jarray_buf, 0);
+            }
+            else {
+                logi("    invalid size !");
+                mBuf = NULL;
+            }
+        }
+        logi("Construct ByteArray from java object FINISH");
+	}
+    
+    VALUE makeVALUE() {
+        logi("make VALUE from byte array START");
+        if (mBuf != NULL) {
+            VALUE v = rho_ruby_create_byte_array(mBuf, mSize);
+            logi("make VALUE from byte array FINISH");
+            return v;
+        }
+        else  {
+            logi("make VALUE from byte array FINISH NIL");
+            return rho_ruby_get_NIL();
+        }
+        
+    }
 
-extern "C" void rho_nfc_tech_close(const char* name) {
 
-}
+	virtual ~CNFCByteArray() {
+        if (mBuf != NULL) {
+            delete mBuf;
+        }
+	}
 
-extern "C" int rho_nfc_tech_is_connected(const char* name) {
-       return 0;
-}
+	unsigned char* mBuf;
+	int mSize;
+};
 
-extern "C" int rho_nfc_tech_MifareClassic_get_size() {
-       return 0;
-}
 
-extern "C" void rho_nfc_tech_MifareClassic_write_block(int index, VALUE block) {
 
-}
 
-extern "C" VALUE rho_nfc_tech_MifareClassic_read_block(int index) {
-       return rho_ruby_get_NIL();
+VALUE JavaHelper_exec_bytearray_bytearray(VALUE array, const char* method_name) {
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) {
+        loge("Nfc class not found !");
+        return rho_ruby_get_NIL();
+    }
+    jmethodID mid = env->GetStaticMethodID(cls.get(), method_name, "([B)[B");
+    if (!mid) { 
+        loge("Nfc method :");
+        loge(method_name);
+        loge("NOT FOUND !");
+        return rho_ruby_get_NIL();
+    }
+    int size = rho_ruby_unpack_byte_array(array, 0, 0);
+    jbyteArray buf_j = (jbyteArray)env->NewByteArray(size);
+    jbyte* buf_p = env->GetByteArrayElements(buf_j, 0);
+    
+    rho_ruby_unpack_byte_array(array, (unsigned char*)buf_p, size);
+    
+    jbyteArray j_arr =  (jbyteArray)env->CallStaticObjectMethod(cls.get(), mid, buf_j);
+    
+    env->ReleaseByteArrayElements(buf_j, buf_p, 0);
+    env->DeleteLocalRef(buf_j);
+    
+    CNFCByteArray ar(env, j_arr);
+    
+    return ar.makeVALUE();
 }
 
-extern "C" int rho_nfc_tech_MifareUltralight_get_size() {
-       return 0;
+void JavaHelper_exec_void_bytearray(VALUE array, const char* method_name) {
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) {
+        loge("Nfc class not found !");
+        return;
+    }
+    jmethodID mid = env->GetStaticMethodID(cls.get(), method_name, "([B)V");
+    if (!mid) { 
+        loge("Nfc method :");
+        loge(method_name);
+        loge("NOT FOUND !");
+        return;
+    }
+    int size = rho_ruby_unpack_byte_array(array, 0, 0);
+    jbyteArray buf_j = (jbyteArray)env->NewByteArray(size);
+    jbyte* buf_p = env->GetByteArrayElements(buf_j, 0);
+    
+    rho_ruby_unpack_byte_array(array, (unsigned char*)buf_p, size);
+    
+    env->CallStaticVoidMethod(cls.get(), mid, buf_j);
+    
+    env->ReleaseByteArrayElements(buf_j, buf_p, 0);
+    env->DeleteLocalRef(buf_j);
 }
 
-extern "C" void rho_nfc_tech_MifareUltralight_write_page(int index, VALUE block) {
-
+VALUE JavaHelper_exec_bytearray_void(const char* method_name) {
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) {
+        loge("Nfc class not found !");
+        return rho_ruby_get_NIL();
+    }
+    jmethodID mid = env->GetStaticMethodID(cls.get(), method_name, "()[B");
+    if (!mid) { 
+        loge("Nfc method :");
+        loge(method_name);
+        loge("NOT FOUND !");
+        return rho_ruby_get_NIL();
+    }
+    jbyteArray j_arr =  (jbyteArray)env->CallStaticObjectMethod(cls.get(), mid);
+    
+    CNFCByteArray ar(env, j_arr);
+    
+    return ar.makeVALUE();
 }
 
-extern "C" VALUE rho_nfc_tech_MifareUltralight_read_pages(int index) {
-       return rho_ruby_get_NIL();
+int JavaHelper_exec_int_void(const char* method_name) {
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) {
+        loge("Nfc class not found !");
+        return 0;
+    }
+    jmethodID mid = env->GetStaticMethodID(cls.get(), method_name, "()I");
+    if (!mid) { 
+        loge("Nfc method :");
+        loge(method_name);
+        loge("NOT FOUND !");
+        return 0;
+    }
+    return env->CallStaticIntMethod(cls.get(), mid);
 }
 
-
-//  private native void callTechCallback(String callback_url, String event);
-extern "C" void JNICALL Java_com_rhomobile_nfc_Nfc_callTechCallback
-(JNIEnv *env, jclass, jstring js_callback_url, jstring js_event)
-{
-	char url[2048];
-	char body[2048];
-
-	const char* jurl = env->GetStringUTFChars(js_callback_url,0);
-	const char* jevent = env->GetStringUTFChars(js_event,0);
-	strcpy(url, jurl);
-	env->ReleaseStringUTFChars(js_callback_url, jurl);
-
-	strcpy(body, "&rho_callback=1");
-	strcat(body, "&");
-	strcat(body, "Tag_event=");
-	strcat(body, jevent);
-	env->ReleaseStringUTFChars(js_event, jevent);
-
-	rho_net_request_with_data(rho_http_normalizeurl(url), body);
+void JavaHelper_exec_void_int(int value, const char* method_name) {
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) {
+        loge("Nfc class not found !");
+        return;
+    }
+    jmethodID mid = env->GetStaticMethodID(cls.get(), method_name, "(I)V");
+    if (!mid) { 
+        loge("Nfc method :");
+        loge(method_name);
+        loge("NOT FOUND !");
+        return;
+    }
+    env->CallStaticVoidMethod(cls.get(), mid, value);
 }
 
 
-
-
-
-
-
-
-
-
+static bool ourNeedToFree = false;
 static jclass jclass_NfcMessagePack = NULL;
 static jclass jclass_NfcMessage = NULL;
 static jclass jclass_NfcRecord = NULL;
@@ -163,6 +339,8 @@ static jmethodID jmethod_NfcMessagePack_getItem = NULL;
 static jmethodID jmethod_NfcMessage_getItemCount = NULL;
 static jmethodID jmethod_NfcMessage_getItem = NULL;
 static jmethodID jmethod_NfcMessage_getByteArray = NULL;
+static jmethodID jmethod_NfcMessage_addConstructRecord = NULL;
+static jmethodID jmethod_NfcMessage_initFromConstructRecordList = NULL;
 
 static jmethodID jmethod_NfcRecord_getId = NULL;
 static jmethodID jmethod_NfcRecord_getPayload = NULL;
@@ -174,72 +352,60 @@ static jmethodID jmethod_NfcRecord_getSubrecords = NULL;
 
 
 
-class CNFCString {
-public:
-	CNFCString(JNIEnv* env, jobject jo_string) {
-		const char* msg = env->GetStringUTFChars((jstring)jo_string,0);
-		mSize = strlen(msg);
-		mBuf = new char[mSize+1];
-		strcpy(mBuf, msg);
-		env->ReleaseStringUTFChars((jstring)jo_string, msg);
-	}
-
-	virtual ~CNFCString() {
-		delete mBuf;
-	}
-
-	char* mBuf;
-	int mSize;
-};
-
-
-
-class CNFCByteArray {
-public:
-	CNFCByteArray(JNIEnv* env, jobject jo_bytearray) {
-        logi("Construct ByteArray from java object START");
-		mSize = env->GetArrayLength((jbyteArray)jo_bytearray);
-        if (mSize > 0) {
-            if (logging_enable) {
-                char msg[128];
-                sprintf(msg, "    array size = %d", mSize);
-                logi(msg);
-            }
-            mBuf = new unsigned char[mSize];
-            unsigned char* jarray_buf = (unsigned char*)env->GetByteArrayElements((jbyteArray)jo_bytearray, 0);
-            int i;
-            for (i = 0; i < mSize; i++) {
-                mBuf[i] = jarray_buf[i];
-            }
-            env->ReleaseByteArrayElements((jbyteArray)jo_bytearray, (jbyte*)jarray_buf, 0);
-        }
-        else {
-            logi("    invalid size !");
-            mBuf = NULL;
-        }
-        logi("Construct ByteArray from java object FINISH");
-	}
-
-
-	virtual ~CNFCByteArray() {
-        if (mBuf != NULL) {
-            delete mBuf;
-        }
-	}
-
+void initJavaIds(JNIEnv *env_param = NULL) {
+    
+    JNIEnv *env = NULL;//jnienv();
+    if (env_param != NULL) {
+        env = env_param;
+    }
+    else {
+        env = jnienv();
+    }
+    
+    if (env_param != NULL) {
+        jclass_NfcMessagePack = env->FindClass("com/rhomobile/nfc/NfcMessagePack");
+        jclass_NfcMessage = env->FindClass("com/rhomobile/nfc/NfcMessage");
+        jclass_NfcRecord = env->FindClass("com/rhomobile/nfc/NfcRecord");
+        ourNeedToFree = false;
+    }
+    else {
+        jclass_NfcMessagePack = rho_find_class(env, "com/rhomobile/nfc/NfcMessagePack");
+        jclass_NfcMessage = rho_find_class(env, "com/rhomobile/nfc/NfcMessage");
+        jclass_NfcRecord = rho_find_class(env, "com/rhomobile/nfc/NfcRecord");
+        ourNeedToFree = true;
+    }
+	// fill java ids
+    
+	jmethod_NfcMessagePack_getItemCount = env->GetMethodID( jclass_NfcMessagePack, "getItemCount", "()I");
+	jmethod_NfcMessagePack_getItem = env->GetMethodID( jclass_NfcMessagePack, "getItem", "(I)Lcom/rhomobile/nfc/NfcMessage;");
+    
+	jmethod_NfcMessage_getItemCount = env->GetMethodID( jclass_NfcMessage, "getItemCount", "()I");
+	jmethod_NfcMessage_getItem = env->GetMethodID( jclass_NfcMessage, "getItem", "(I)Lcom/rhomobile/nfc/NfcRecord;");
+	jmethod_NfcMessage_getByteArray = env->GetMethodID( jclass_NfcMessage, "getByteArray", "()[B");
+	jmethod_NfcMessage_addConstructRecord = env->GetMethodID( jclass_NfcMessage, "addConstructRecord", "(Lcom/rhomobile/nfc/NfcRecord;)V");
+	jmethod_NfcMessage_initFromConstructRecordList = env->GetMethodID( jclass_NfcMessage, "initFromConstructRecordList", "()V");
+    
+	jmethod_NfcRecord_getId = env->GetMethodID( jclass_NfcRecord, "getId", "()[B");
+	jmethod_NfcRecord_getPayload = env->GetMethodID( jclass_NfcRecord, "getPayload", "()[B");
+	jmethod_NfcRecord_getPayloadString = env->GetMethodID( jclass_NfcRecord, "getPayloadString", "()Ljava/lang/String;");
+	jmethod_NfcRecord_getTnf = env->GetMethodID( jclass_NfcRecord, "getTnf", "()I");
+	jmethod_NfcRecord_getType = env->GetMethodID( jclass_NfcRecord, "getType", "()[B");
+	jmethod_NfcRecord_getByteArray = env->GetMethodID( jclass_NfcRecord, "getByteArray", "()[B");
+	jmethod_NfcRecord_getSubrecords = env->GetMethodID( jclass_NfcRecord, "getSubrecords", "()Lcom/rhomobile/nfc/NfcMessage;");
+    
+}
 
-	unsigned char* mBuf;
-	int mSize;
-};
 
 class CNFCMessage;
 
 class CNFCRecord {
 public:
 	CNFCRecord(JNIEnv* env, jobject jrec); 
-
+    
+    VALUE makeHashValue();
+    
 	virtual ~CNFCRecord();
-
+    
 	CNFCByteArray* mId;
 	CNFCByteArray* mPayload;
 	CNFCString* mPayloadString;
@@ -263,7 +429,7 @@ public:
 		}
 		mByteArray = new CNFCByteArray(env, env->CallObjectMethod(jmsg, jmethod_NfcMessage_getByteArray));
 	}
-
+    
 	virtual ~CNFCMessage() {
 		int i;
 		for (i = 0; i < mRecordCount; i++) {
@@ -272,7 +438,9 @@ public:
 		delete[] mRecords;
 		delete mByteArray;
 	}
-
+    
+    VALUE makeHashValue();
+    
 	CNFCRecordPtr* mRecords;
 	int mRecordCount;
 	CNFCByteArray* mByteArray;
@@ -305,10 +473,40 @@ CNFCRecord::~CNFCRecord() {
 	}
 }
 
+VALUE CNFCRecord::makeHashValue() {
+    VALUE hash = rho_ruby_createHash();
+    rho_ruby_add_to_hash(hash, rho_ruby_create_string("raw_record"), mByteArray->makeVALUE());
+    rho_ruby_add_to_hash(hash, rho_ruby_create_string("id"), mId->makeVALUE());
+    rho_ruby_add_to_hash(hash, rho_ruby_create_string("payload"), mPayload->makeVALUE());
+    rho_ruby_add_to_hash(hash, rho_ruby_create_string("tnf"), rho_ruby_create_integer(mTnf));
+    rho_ruby_add_to_hash(hash, rho_ruby_create_string("type"), mType->makeVALUE());
+    rho_ruby_add_to_hash(hash, rho_ruby_create_string("payload_as_string"), mPayloadString->makeVALUE());
+    if (mSubrecords != NULL) {
+        rho_ruby_add_to_hash(hash, rho_ruby_create_string("subrecords"), mSubrecords->makeHashValue());
+    }
+    return hash;
+}
+
+VALUE CNFCMessage::makeHashValue() {
+    VALUE hash = rho_ruby_createHash();
+    rho_ruby_add_to_hash(hash, rho_ruby_create_string("raw_message"), mByteArray->makeVALUE());
+    
+    VALUE records = rho_ruby_create_array();
+    int i;
+    for (i = 0; i < mRecordCount; i++) {
+        rho_ruby_add_to_array(records, mRecords[i]->makeHashValue());
+    }
+    
+    rho_ruby_add_to_hash(hash, rho_ruby_create_string("records"), records);
+    
+    return hash;
+    
+}
+
 
 class CNFCMessagePack {
 public:
-
+    
 	CNFCMessagePack(JNIEnv* env, jobject jmsg_pack) {
 		mMessageCount = env->CallIntMethod(jmsg_pack, jmethod_NfcMessagePack_getItemCount);
 		int i;
@@ -317,7 +515,7 @@ public:
 			mMessages[i] = new CNFCMessage(env, env->CallObjectMethod(jmsg_pack, jmethod_NfcMessagePack_getItem, i));
 		}
 	}
-
+    
 	virtual ~CNFCMessagePack() {
 		int i;
 		for (i = 0; i < mMessageCount; i++) {
@@ -325,7 +523,7 @@ public:
 		}
 		delete[] mMessages;
 	}
-
+    
 	CNFCMessagePtr* mMessages;
     int mMessageCount;
 };
@@ -338,16 +536,16 @@ public:
 	RhoCallbackNFCContainer(CNFCMessagePack* pack) {
 		mMessagePack = pack;
 	}
-
+    
 	virtual ~RhoCallbackNFCContainer() {
 		delete mMessagePack;
 	}
-
+    
 	VALUE makeString(CNFCString* str) {
         logi("                make ruby string");
 		return rho_ruby_create_string((const char*)str->mBuf);
 	}
-   
+    
 	VALUE makeByteArray(CNFCByteArray* array) {
         logi("                make ruby byte array");
         if (array->mBuf != NULL) {
@@ -363,110 +561,738 @@ public:
             return rho_ruby_get_NIL();
         }
 	}
-
-	VALUE makeRecordHash(CNFCRecord* record) {
-        logi("            make record START");
-		VALUE hash = rho_ruby_createHash();
-		rho_ruby_add_to_hash(hash, rho_ruby_create_string("raw_record"), makeByteArray(record->mByteArray));
-		rho_ruby_add_to_hash(hash, rho_ruby_create_string("id"), makeByteArray(record->mId));
-		rho_ruby_add_to_hash(hash, rho_ruby_create_string("payload"), makeByteArray(record->mPayload));
-		rho_ruby_add_to_hash(hash, rho_ruby_create_string("tnf"), rho_ruby_create_integer(record->mTnf));
-		rho_ruby_add_to_hash(hash, rho_ruby_create_string("type"), makeByteArray(record->mType));
-		rho_ruby_add_to_hash(hash, rho_ruby_create_string("payload_as_string"), makeString(record->mPayloadString));
-		if (record->mSubrecords != NULL) {
-			rho_ruby_add_to_hash(hash, rho_ruby_create_string("subrecords"), makeMessageHash(record->mSubrecords));
-		}
-        logi("            make record FINISH");
-		return hash;
-	}
-
-	VALUE makeMessageHash(CNFCMessage* msg) {
-        logi("        make message START");
-		VALUE hash = rho_ruby_createHash();
-		rho_ruby_add_to_hash(hash, rho_ruby_create_string("raw_message"), makeByteArray(msg->mByteArray));
-
-		VALUE records = rho_ruby_create_array();
-		int i;
-        logi("        make message make records :");
-		for (i = 0; i < msg->mRecordCount; i++) {
-			rho_ruby_add_to_array(records, makeRecordHash(msg->mRecords[i]));
-		}
-
-		rho_ruby_add_to_hash(hash, rho_ruby_create_string("records"), records);
-
-        logi("        make message FINISH");
-		return hash;
-	}
-
-
+    
+    
 	/*
-	# in callback
-	# @params['messages'] - array of messages (each message is hash)
-	# message hash items : 
-	#       'raw_message' - array of bytes (raw message)
-	#       'records' - array of records (each record is hash)
-	#              record hash items :
-	#                     'raw_record' - array of bytes (raw record)
-	#                     ' id' - array of bytes
-	#                     'payload' - array of bytes
-	#                     'tnf' - int
-	#                     'type' - array of bytes 
-	#                     'payload_as_string' - string, payload prepared to string (support specail formats for URI, TEXT) 
-	#                     'subrecords' - array of subrecords, each records is hash (only for SMART_POSTER type)
-	*/
-
+     # in callback
+     # @params['messages'] - array of messages (each message is hash)
+     # message hash items : 
+     #       'raw_message' - array of bytes (raw message)
+     #       'records' - array of records (each record is hash)
+     #              record hash items :
+     #                     'raw_record' - array of bytes (raw record)
+     #                     ' id' - array of bytes
+     #                     'payload' - array of bytes
+     #                     'tnf' - int
+     #                     'type' - array of bytes 
+     #                     'payload_as_string' - string, payload prepared to string (support specail formats for URI, TEXT) 
+     #                     'subrecords' - array of subrecords, each records is hash (only for SMART_POSTER type)
+     */
+    
 	// return Ruby object
 	virtual unsigned long getObjectValue() {
 		logi("make Ruby value for callback START");
-
+        
 		VALUE messages_array = rho_ruby_create_array();
 		int i;
-
+        
 		logi("    make messages array :");
 		for (i = 0; i < mMessagePack->mMessageCount; i++) {
-			rho_ruby_add_to_array(messages_array, makeMessageHash(mMessagePack->mMessages[i]));	
+			rho_ruby_add_to_array(messages_array, mMessagePack->mMessages[i]->makeHashValue());	
 		}
-
+        
 		logi("make Ruby value for callback FINISH");
 		return messages_array;
 	}
-
+    
 private:
 	CNFCMessagePack*	mMessagePack;
 };
 
 
-//  private native void callCallback(String callback_url, NfcMessagePack msgpack);
-extern "C" void JNICALL Java_com_rhomobile_nfc_Nfc_callCallback
-(JNIEnv *env, jclass, jstring js_callback_url, jobject jo_msgpack)
+
+
+
+
+
+
+
+extern "C" void rho_nfc_set_callback(const char* callback_url) {
+	JNIEnv *env = jnienv();
+	CNfcJavaClass cls;
+	if (!cls.get()) return;
+	jmethodID mid = env->GetStaticMethodID( cls.get(), "setCallback", "(Ljava/lang/String;)V");
+	if (!mid) return;
+	jstring objCallback = env->NewStringUTF(callback_url);
+	env->CallStaticVoidMethod(cls.get(), mid, objCallback);
+	env->DeleteLocalRef(objCallback);
+}
+
+extern "C" void rho_nfc_enable(int enable) {
+	JNIEnv *env = jnienv();
+	CNfcJavaClass cls;
+	if (!cls.get()) return;
+	jmethodID mid = env->GetStaticMethodID( cls.get(), "setEnable", "(I)V");
+	if (!mid) return;
+	env->CallStaticVoidMethod(cls.get(), mid, enable);
+}
+
+extern "C" int rho_nfc_is_enabled(void) {
+    return JavaHelper_exec_int_void("isEnabled");    
+}
+
+extern "C" int rho_nfc_is_supported(void) {
+    return JavaHelper_exec_int_void("isSupported");    
+}
+
+extern "C" void rho_nfc_set_tech_callback(const char* callback_url) {
+	JNIEnv *env = jnienv();
+	CNfcJavaClass cls;
+	if (!cls.get()) return;
+	jmethodID mid = env->GetStaticMethodID( cls.get(), "setTechCallback", "(Ljava/lang/String;)V");
+	if (!mid) return;
+	jstring objCallback = env->NewStringUTF(callback_url);
+	env->CallStaticVoidMethod(cls.get(), mid, objCallback);
+	env->DeleteLocalRef(objCallback);
+}
+
+extern "C" void rho_nfc_perform_open_application_event() {
+	JNIEnv *env = jnienv();
+	CNfcJavaClass cls;
+	if (!cls.get()) return;
+	jmethodID mid = env->GetStaticMethodID( cls.get(), "performOpenApplicationTag", "()V");
+	if (!mid) return;
+	env->CallStaticVoidMethod(cls.get(), mid);
+}
+
+
+
+extern "C" void rho_nfc_set_listen_tech_list(VALUE tech_list) {
+
+}
+
+extern "C" VALUE rho_nfc_get_tech_list() {
+
+    logi("rho_nfc_get_tech_list START");
+	JNIEnv *env = jnienv();
+	CNfcJavaClass cls;
+	if (!cls.get()) return rho_ruby_get_NIL();
+	jmethodID mid = env->GetStaticMethodID( cls.get(), "get_tech_list_count", "()I");
+	if (!mid) return rho_ruby_get_NIL();
+	jmethodID mids = env->GetStaticMethodID( cls.get(), "get_tech_list", "(I)Ljava/lang/String;");
+	if (!mids) return rho_ruby_get_NIL();
+	int count =  env->CallStaticIntMethod(cls.get(), mid);
+
+	VALUE array = rho_ruby_create_array();
+
+	int i;
+    
+	for (i = 0; i < count; i++) {
+		CNFCString  cs(env, env->CallStaticObjectMethod(cls.get(), mids, i));
+		rho_ruby_add_to_array( array, rho_ruby_create_string(cs.mBuf));
+        logi("rho_nfc_get_tech_list 05");
+
+	}
+	return array;
+}
+
+extern "C" void rho_nfc_tech_connect(const char* name) {
+    logi("rho_nfc_tech_connect START");
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return;
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_connect", "(Ljava/lang/String;)V");
+    if (!mid) return;
+    jstring objCallback = env->NewStringUTF(name);
+    env->CallStaticVoidMethod(cls.get(), mid, objCallback);
+    env->DeleteLocalRef(objCallback);
+    logi("rho_nfc_tech_connect FINISH");
+}
+
+extern "C" void rho_nfc_tech_close(const char* name) {
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return;
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_close", "(Ljava/lang/String;)V");
+    if (!mid) return;
+    jstring objCallback = env->NewStringUTF(name);
+    env->CallStaticVoidMethod(cls.get(), mid, objCallback);
+    env->DeleteLocalRef(objCallback);
+}
+
+extern "C" int rho_nfc_tech_is_connected(const char* name) {
+    logi("rho_nfc_tech_is_connected START");
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return 0;
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_is_connected", "(Ljava/lang/String;)I");
+    if (!mid) return 0;
+    jstring objCallback = env->NewStringUTF(name);
+    int res = env->CallStaticIntMethod(cls.get(), mid, objCallback);
+    env->DeleteLocalRef(objCallback);
+    logi("rho_nfc_tech_is_connected FINISH");
+    return res;    
+}
+
+extern "C" int rho_nfc_tech_MifareClassic_get_size() {
+    return JavaHelper_exec_int_void("tech_MifareClassic_get_size");    
+}
+
+extern "C" void rho_nfc_tech_MifareClassic_write_block(int index, VALUE block) {
+
+    logi("rho_nfc_tech_MifareClassic_write_block START");
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return;
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_MifareClassic_write_block", "(I[B)V");
+    if (!mid) return;
+    
+    int res = 0;
+    jbyteArray buf_j = (jbyteArray)env->NewByteArray(16);
+    jbyte* buf_p = env->GetByteArrayElements(buf_j, 0);
+    
+    rho_ruby_unpack_byte_array(block, (unsigned char*)buf_p, 16);
+    
+    env->CallStaticVoidMethod(cls.get(), mid, index, buf_j);
+    
+    env->ReleaseByteArrayElements(buf_j, buf_p, 0);
+    env->DeleteLocalRef(buf_j);
+    
+    logi("rho_nfc_tech_MifareClassic_write_block FINISH");
+    
+}
+
+extern "C" VALUE rho_nfc_tech_MifareClassic_read_block(int index) {
+
+    logi("rho_nfc_tech_MifareClassic_read_block START");
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_MifareClassic_read_block", "(I[B)I");
+    if (!mid) return rho_ruby_get_NIL();
+
+    VALUE val = rho_ruby_get_NIL();
+    jbyteArray buf_j = (jbyteArray)env->NewByteArray(16);
+    int res = env->CallStaticIntMethod(cls.get(), mid, index, buf_j);
+    jbyte* buf_p = env->GetByteArrayElements(buf_j, 0);
+    if (res != 0) {
+          logi("java Nfc return real array");
+          val = rho_ruby_create_byte_array((unsigned char*)buf_p, 16);
+    }
+    else {
+          logi("java Nfc not filled array !!!");
+    }
+    env->ReleaseByteArrayElements(buf_j, buf_p, 0);
+    env->DeleteLocalRef(buf_j);
+    logi("rho_nfc_tech_MifareClassic_read_block FINISH");
+
+    return val;
+}
+
+extern "C" int rho_nfc_tech_MifareClassic_get_block_count() {
+    return JavaHelper_exec_int_void("tech_MifareClassic_get_block_count");
+}
+
+extern "C" int rho_nfc_tech_MifareClassic_get_sector_count() {
+    return JavaHelper_exec_int_void("tech_MifareClassic_get_sector_count");
+}
+
+extern "C" int rho_nfc_tech_MifareClassic_get_blocks_in_sector_count(int index) {
+    logi("rho_nfc_tech_MifareClassic_get_blocks_in_sector_count START");    
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return 0;
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_MifareClassic_get_blocks_in_sector_count", "(I)I");
+    if (!mid) return 0;
+    logi("rho_nfc_tech_MifareClassic_get_blocks_in_sector_count FINISH");    
+    return env->CallStaticIntMethod(cls.get(), mid, index);
+}
+
+extern "C" int rho_nfc_tech_MifareClassic_sector_to_block(int index) {
+    logi("rho_nfc_tech_MifareClassic_sector_to_block START");    
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return 0;
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_MifareClassic_sector_to_block", "(I)I");
+    if (!mid) return 0;
+    logi("rho_nfc_tech_MifareClassic_sector_to_block FINISH");    
+    return env->CallStaticIntMethod(cls.get(), mid, index);
+}
+
+extern "C" int rho_nfc_tech_MifareClassic_get_type() {
+    return JavaHelper_exec_int_void("tech_MifareClassic_get_type");
+}
+
+extern "C" VALUE rho_nfc_tech_MifareClassic_transceive(VALUE data) {
+    return JavaHelper_exec_bytearray_bytearray(data, "tech_MifareClassic_transceive");
+}
+
+extern "C" VALUE rho_nfc_tag_get_id() {
+    return JavaHelper_exec_bytearray_void("tag_get_id");
+}
+
+
+extern "C" int rho_nfc_tech_MifareClassic_authenticate_sector_with_key_A(int index, VALUE key) {
+
+    logi("rho_nfc_tech_MifareClassic_authenticate_sector_with_key_A START");
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return 0;
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_MifareClassic_authenticate_sector_with_key_A", "(I[B)I");
+    if (!mid) return 0;
+    
+    int res = 0;
+    jbyteArray buf_j = (jbyteArray)env->NewByteArray(6);
+    jbyte* buf_p = env->GetByteArrayElements(buf_j, 0);
+    
+    rho_ruby_unpack_byte_array(key, (unsigned char*)buf_p, 6);
+    
+    res = env->CallStaticIntMethod(cls.get(), mid, index, buf_j);
+
+    env->ReleaseByteArrayElements(buf_j, buf_p, 0);
+    env->DeleteLocalRef(buf_j);
+    
+    logi("rho_nfc_tech_MifareClassic_authenticate_sector_with_key_A FINISH");
+    
+    return res;
+    
+}
+
+extern "C" int rho_nfc_tech_MifareClassic_authenticate_sector_with_key_B(int index, VALUE key) {
+    logi("rho_nfc_tech_MifareClassic_authenticate_sector_with_key_B START");
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return 0;
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_MifareClassic_authenticate_sector_with_key_B", "(I[B)I");
+    if (!mid) return 0;
+    
+    int res = 0;
+    jbyteArray buf_j = (jbyteArray)env->NewByteArray(6);
+    jbyte* buf_p = env->GetByteArrayElements(buf_j, 0);
+    
+    rho_ruby_unpack_byte_array(key, (unsigned char*)buf_p, 6);
+    
+    res = env->CallStaticIntMethod(cls.get(), mid, index, buf_j);
+    
+    env->ReleaseByteArrayElements(buf_j, buf_p, 0);
+    env->DeleteLocalRef(buf_j);
+    
+    logi("rho_nfc_tech_MifareClassic_authenticate_sector_with_key_B FINISH");
+    
+    return res;
+    
+}
+
+
+extern "C" int rho_nfc_tech_Ndef_get_max_size() {
+    return JavaHelper_exec_int_void("tech_Ndef_get_max_size");
+}
+
+// return string
+extern "C" VALUE rho_nfc_tech_Ndef_get_type() {
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_Ndef_get_type", "()Ljava/lang/String;");
+    if (!mid) return rho_ruby_get_NIL();
+    jstring j_str =  (jstring)env->CallStaticObjectMethod(cls.get(), mid);
+    CNFCString s(env, j_str);
+    return s.makeVALUE();
+}
+
+extern "C" int rho_nfc_tech_Ndef_is_writable() {
+    return JavaHelper_exec_int_void("tech_Ndef_is_writable");
+}
+
+extern "C" int rho_nfc_tech_Ndef_can_make_read_only() {
+    return JavaHelper_exec_int_void("tech_Ndef_can_make_read_only");
+}
+
+extern "C" int rho_nfc_tech_Ndef_make_read_only() {
+    return JavaHelper_exec_int_void("tech_Ndef_make_read_only");
+}
+
+extern "C" void rho_nfc_tech_Ndef_write_Nde_message(VALUE message_in_byte_array) {
+    JavaHelper_exec_void_bytearray(message_in_byte_array, "tech_Ndef_write_Nde_message");
+}
+
+// return byte[]
+extern "C" VALUE rho_nfc_tech_Ndef_read_Nde_message() {
+    return JavaHelper_exec_bytearray_void("tech_Ndef_read_Nde_message");
+}
+
+// return byte[]
+extern "C" VALUE rho_nfc_tech_NfcA_get_Atqa() {
+    return JavaHelper_exec_bytearray_void("tech_NfcA_get_Atqa");
+}
+
+extern "C" int rho_nfc_tech_NfcA_get_Sak() {
+    return JavaHelper_exec_int_void("tech_NfcA_get_Sak");
+}
+
+// return byte[]
+extern "C" VALUE rho_nfc_tech_NfcA_transceive(VALUE data) {
+    return JavaHelper_exec_bytearray_bytearray(data, "tech_NfcA_transceive");
+}
+
+
+// return HASH
+extern "C" VALUE rho_nfc_convert_byte_array_to_NdeRecord_hash(VALUE array) {
+    initJavaIds();
+    
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "convert_byte_array_to_NdeRecord_hash", "([B)Lcom/rhomobile/nfc/NfcRecord;");
+    if (!mid) return rho_ruby_get_NIL();
+    
+    int size = rho_ruby_unpack_byte_array(array, 0, 0);
+    jbyteArray buf_j = (jbyteArray)env->NewByteArray(size);
+    jbyte* buf_p = env->GetByteArrayElements(buf_j, 0);
+    
+    rho_ruby_unpack_byte_array(array, (unsigned char*)buf_p, size);
+    
+    jobject j_o =  env->CallStaticObjectMethod(cls.get(), mid, buf_j);
+    
+    env->ReleaseByteArrayElements(buf_j, buf_p, 0);
+    env->DeleteLocalRef(buf_j);
+    
+    CNFCRecord r(env, j_o);
+    
+    return r.makeHashValue();
+}
+
+// return byte array
+extern "C" VALUE rho_nfc_convert_NdeRecord_hash_to_byte_array(VALUE hash) {
+    initJavaIds();
+
+    VALUE ruby_id = rho_ruby_hash_aref(hash, "id");
+    VALUE ruby_type = rho_ruby_hash_aref(hash, "type");
+    VALUE ruby_payload = rho_ruby_hash_aref(hash, "payload");
+    VALUE ruby_tnf = rho_ruby_hash_aref(hash, "tnf");
+
+    int tnf = (int)rho_ruby_get_int(ruby_tnf);
+    CRubyByteArray c_id(ruby_id);
+    CRubyByteArray c_type(ruby_type);
+    CRubyByteArray c_payload(ruby_payload);
+    
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "convert_NdeRecord_hash_to_byte_array", "([B[BI[B)[B");
+    if (!mid) return rho_ruby_get_NIL();
+    
+    jbyteArray j_result = (jbyteArray)env->CallStaticObjectMethod(cls.get(), mid, c_id.makeJavaByteArray(env), c_payload.makeJavaByteArray(env), tnf, c_type.makeJavaByteArray(env));
+    
+    CNFCByteArray ar(env, j_result);
+    
+    return ar.makeVALUE();
+}
+
+// return array of byte array
+extern "C" VALUE rho_nfc_convert_NdeMessage_byte_array_to_NdeRecords_array(VALUE array) {
+    
+    initJavaIds();
+
+    CRubyByteArray c_msg(array);
+
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "convert_NdeMessage_byte_array_to_NdeRecords_array", "([B)Lcom/rhomobile/nfc/NfcMessage;");
+    if (!mid) return rho_ruby_get_NIL();
+    
+    jobject j_msg = env->CallStaticObjectMethod(cls.get(), mid, c_msg.makeJavaByteArray(env));
+    
+    CNFCMessage msg(env, j_msg);
+    
+    int i;
+    
+    VALUE result = rho_ruby_create_array();
+    
+    for (i = 0; i < msg.mRecordCount; i++) {
+        CNFCRecord* rec = msg.mRecords[i];
+        rho_ruby_add_to_array(result, rec->mByteArray->makeVALUE());   
+        
+    }
+    
+    return result;
+}
+
+// return byte array
+extern "C" VALUE rho_nfc_convert_NdeRecords_array_to_NdeMessage_byte_array(VALUE array) {
+    initJavaIds();
+    
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid_make_msg = env->GetStaticMethodID(cls.get(), "make_empty_NfcMessage", "()Lcom/rhomobile/nfc/NfcMessage;");
+    if (!mid_make_msg) return rho_ruby_get_NIL();
+    jmethodID mid_make_rec = env->GetStaticMethodID(cls.get(), "convert_byte_array_to_NdeRecord_hash", "([B)Lcom/rhomobile/nfc/NfcRecord;");
+    if (!mid_make_rec) return rho_ruby_get_NIL();
+    
+    jobject j_msg = env->CallStaticObjectMethod(cls.get(), mid_make_msg);
+    
+    int count = rho_ruby_array_get_size(array);
+    int i;
+    
+    for (i = 0; i < count; i++) {
+        CRubyByteArray c_rec(rho_ruby_array_get(array, i));
+        
+        jobject j_rec = env->CallStaticObjectMethod(cls.get(), mid_make_rec, c_rec.makeJavaByteArray(env));
+        
+        env->CallVoidMethod(j_msg, jmethod_NfcMessage_addConstructRecord, j_rec);
+    }
+    env->CallVoidMethod(j_msg, jmethod_NfcMessage_initFromConstructRecordList);
+    
+    CNFCByteArray ar(env, env->CallObjectMethod(j_msg, jmethod_NfcMessage_getByteArray));
+    
+    return ar.makeVALUE();
+    
+}
+
+// String make_string_from_payload(byte[] payload, int tnf, byte[] type)
+// return string
+extern "C" VALUE rho_nfc_make_string_from_payload(VALUE payload, int tnf, VALUE type) {
+    
+    CRubyByteArray c_payload(payload);
+    CRubyByteArray c_type(type);
+    
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "make_string_from_payload", "([BI[B)Ljava/lang/String;");
+    if (!mid) return rho_ruby_get_NIL();
+    
+    jstring j_s = (jstring)env->CallStaticObjectMethod(cls.get(), mid, c_payload.makeJavaByteArray(env), tnf, c_type.makeJavaByteArray(env));
+    
+    CNFCString s(env, j_s);
+    
+    return s.makeVALUE();
+}
+
+// return byte[]
+extern "C" VALUE rho_nfc_make_payload_with_absolute_uri(const char* str) {
+    
+    CRubyString c_s(str);
+    
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "make_payload_with_absolute_uri", "(Ljava/lang/String;)[B");
+    if (!mid) return rho_ruby_get_NIL();
+    
+    jobject j_o = env->CallStaticObjectMethod(cls.get(), mid, c_s.makeJavaString(env));
+    
+    CNFCByteArray ar(env, j_o);
+    
+    return ar.makeVALUE();
+    
+}
+
+// return byte[]
+extern "C" VALUE rho_nfc_make_payload_with_well_known_text(const char* language, const char* str) {
+    CRubyString c_lang(language);
+    CRubyString c_s(str);
+    
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "make_payload_with_well_known_text", "(Ljava/lang/String;Ljava/lang/String;)[B");
+    if (!mid) return rho_ruby_get_NIL();
+    
+    jobject j_o = env->CallStaticObjectMethod(cls.get(), mid, c_lang.makeJavaString(env), c_s.makeJavaString(env));
+    
+    CNFCByteArray ar(env, j_o);
+    
+    return ar.makeVALUE();
+    
+}
+
+// return byte[]
+extern "C" VALUE rho_nfc_make_payload_with_well_known_uri(int prefix, const char* str) {
+    CRubyString c_s(str);
+    
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "make_payload_with_well_known_uri", "(ILjava/lang/String;)[B");
+    if (!mid) return rho_ruby_get_NIL();
+    
+    jobject j_o = env->CallStaticObjectMethod(cls.get(), mid, prefix, c_s.makeJavaString(env));
+    
+    CNFCByteArray ar(env, j_o);
+    
+    return ar.makeVALUE();
+}
+
+extern "C" void rho_nfc_p2p_enable_foreground_nde_push(VALUE nde_message_byte_array) {
+    JavaHelper_exec_void_bytearray(nde_message_byte_array, "p2p_enable_foreground_nde_push");
+}
+
+extern "C" void rho_nfc_p2p_disable_foreground_nde_push() {
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return;
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "p2p_disable_foreground_nde_push", "()V");
+    if (!mid) return;
+    env->CallStaticVoidMethod(cls.get(), mid);
+}
+
+extern "C" void rho_nfc_tech_MifareUltralight_write_page(int index, VALUE block) {
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return;
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_MifareUltralight_write_page", "(I[B)V");
+    if (!mid) return;
+    
+    int res = 0;
+    int size = rho_ruby_unpack_byte_array(block, 0, 0);
+    jbyteArray buf_j = (jbyteArray)env->NewByteArray(size);
+    jbyte* buf_p = env->GetByteArrayElements(buf_j, 0);
+    
+    rho_ruby_unpack_byte_array(block, (unsigned char*)buf_p, size);
+    
+    env->CallStaticVoidMethod(cls.get(), mid, index, buf_j);
+    
+    env->ReleaseByteArrayElements(buf_j, buf_p, 0);
+    env->DeleteLocalRef(buf_j);
+}
+
+extern "C" VALUE rho_nfc_tech_MifareUltralight_read_pages(int index) {
+    JNIEnv *env = jnienv();
+    CNfcJavaClass cls;
+    if (!cls.get()) return rho_ruby_get_NIL();
+    jmethodID mid = env->GetStaticMethodID(cls.get(), "tech_MifareUltralight_read_pages", "(I)[B");
+    if (!mid) return rho_ruby_get_NIL();
+
+    jbyteArray j_arr =  (jbyteArray)env->CallStaticIntMethod(cls.get(), mid, index);
+
+    CNFCByteArray ar(env, j_arr);
+    
+    return ar.makeVALUE();
+}
+
+extern "C" int rho_nfc_tech_MifareUltralight_get_type() {
+    return JavaHelper_exec_int_void("tech_MifareUltralight_get_type");
+}
+
+extern "C" VALUE rho_nfc_tech_MifareUltralight_transceive(VALUE data) {
+    return JavaHelper_exec_bytearray_bytearray(data, "tech_MifareUltralight_transceive");
+}
+
+
+extern "C" VALUE rho_nfc_tech_IsoDep_get_hi_layer_responce() {
+    return JavaHelper_exec_bytearray_void("tech_IsoDep_get_hi_layer_responce");
+}
+
+extern "C" VALUE rho_nfc_tech_IsoDep_get_historical_bytes() {
+    return JavaHelper_exec_bytearray_void("tech_IsoDep_get_historical_bytes");
+}
+
+extern "C" void rho_nfc_tech_IsoDep_set_timeout(int timeout) {
+    JavaHelper_exec_void_int(timeout, "tech_IsoDep_set_timeout");
+}
+
+extern "C" VALUE rho_nfc_tech_IsoDep_transceive(VALUE data) {
+    return JavaHelper_exec_bytearray_bytearray(data, "tech_IsoDep_transceive");
+}
+
+extern "C" void rho_nfc_tech_NdefFormatable_format(VALUE ndef_message_byte_array) {
+    JavaHelper_exec_void_bytearray(ndef_message_byte_array, "tech_NdefFormatable_format");
+}
+
+extern "C" void rho_nfc_tech_NdefFormatable_format_read_only(VALUE ndef_message_byte_array) {
+    JavaHelper_exec_void_bytearray(ndef_message_byte_array, "tech_NdefFormatable_format_read_only");
+}
+
+// return byte[]
+extern "C" VALUE rho_nfc_tech_NfcB_get_application_data() {
+    return JavaHelper_exec_bytearray_void("tech_NfcB_get_application_data");
+}
+
+// return byte[]
+extern "C" VALUE rho_nfc_tech_NfcB_get_protocol_info() {
+    return JavaHelper_exec_bytearray_void("tech_NfcB_get_protocol_info");
+}
+
+// byte[] -> byte[]
+extern "C" VALUE rho_nfc_tech_NfcB_transceive(VALUE data) {
+    return JavaHelper_exec_bytearray_bytearray(data, "tech_NfcB_transceive");
+}
+
+// return byte[]
+extern "C" VALUE rho_nfc_tech_NfcF_get_manufacturer() {
+    return JavaHelper_exec_bytearray_void("tech_NfcF_get_manufacturer");
+}
+
+// return byte[]
+extern "C" VALUE rho_nfc_tech_NfcF_get_system_code() {
+    return JavaHelper_exec_bytearray_void("tech_NfcF_get_system_code");
+}
+
+// byte[] -> byte[]
+extern "C" VALUE rho_nfc_tech_NfcF_transceive(VALUE data) {
+    return JavaHelper_exec_bytearray_bytearray(data, "tech_NfcF_transceive");
+}
+
+extern "C" int rho_nfc_tech_NfcV_get_dsf_id() {
+    return JavaHelper_exec_int_void("tech_NfcV_get_dsf_id");
+}
+
+extern "C" int rho_nfc_tech_NfcV_get_responce_flags() {
+    return JavaHelper_exec_int_void("tech_NfcV_get_responce_flags");
+}
+
+// byte[] -> byte[]
+extern "C" VALUE rho_nfc_tech_NfcV_transceive(VALUE data) {
+    return JavaHelper_exec_bytearray_bytearray(data, "tech_NfcV_transceive");
+}
+
+
+
+
+
+
+
+//  private native void callTechCallback(String callback_url, String event);
+extern "C" void JNICALL Java_com_rhomobile_nfc_Nfc_callTechCallback
+(JNIEnv *env, jclass, jstring js_callback_url, jstring js_event)
 {
-	logi("native callback START");
-	// fill java ids
-	jclass_NfcMessagePack = env->FindClass("com/rhomobile/nfc/NfcMessagePack");
-	jclass_NfcMessage = env->FindClass("com/rhomobile/nfc/NfcMessage");
-	jclass_NfcRecord = env->FindClass("com/rhomobile/nfc/NfcRecord");
+	char url[2048];
+	char body[2048];
 
-	jmethod_NfcMessagePack_getItemCount = env->GetMethodID( jclass_NfcMessagePack, "getItemCount", "()I");
-	jmethod_NfcMessagePack_getItem = env->GetMethodID( jclass_NfcMessagePack, "getItem", "(I)Lcom/rhomobile/nfc/NfcMessage;");
+	const char* jurl = env->GetStringUTFChars(js_callback_url,0);
+	const char* jevent = env->GetStringUTFChars(js_event,0);
+	strcpy(url, jurl);
+	env->ReleaseStringUTFChars(js_callback_url, jurl);
+
+	strcpy(body, "&rho_callback=1");
+	strcat(body, "&");
+	strcat(body, "Tag_event=");
+	strcat(body, jevent);
+	env->ReleaseStringUTFChars(js_event, jevent);
+
+	rho_net_request_with_data(rho_http_normalizeurl(url), body);
+}
+
+//  private native void callTechCallback(String callback_url, String event);
+extern "C" void JNICALL Java_com_rhomobile_nfc_Nfc_logNative
+(JNIEnv *env, jclass, jstring js_msg)
+{
+	char msg[2048];
+    
+	const char* jmsg = env->GetStringUTFChars(js_msg,0);
+	strcpy(msg, jmsg);
+	env->ReleaseStringUTFChars(js_msg, jmsg);
+  
+	logi(msg);
+}
 
-	jmethod_NfcMessage_getItemCount = env->GetMethodID( jclass_NfcMessage, "getItemCount", "()I");
-	jmethod_NfcMessage_getItem = env->GetMethodID( jclass_NfcMessage, "getItem", "(I)Lcom/rhomobile/nfc/NfcRecord;");
-	jmethod_NfcMessage_getByteArray = env->GetMethodID( jclass_NfcMessage, "getByteArray", "()[B");
 
-	jmethod_NfcRecord_getId = env->GetMethodID( jclass_NfcRecord, "getId", "()[B");
-	jmethod_NfcRecord_getPayload = env->GetMethodID( jclass_NfcRecord, "getPayload", "()[B");
-	jmethod_NfcRecord_getPayloadString = env->GetMethodID( jclass_NfcRecord, "getPayloadString", "()Ljava/lang/String;");
-	jmethod_NfcRecord_getTnf = env->GetMethodID( jclass_NfcRecord, "getTnf", "()I");
-	jmethod_NfcRecord_getType = env->GetMethodID( jclass_NfcRecord, "getType", "()[B");
-	jmethod_NfcRecord_getByteArray = env->GetMethodID( jclass_NfcRecord, "getByteArray", "()[B");
-	jmethod_NfcRecord_getSubrecords = env->GetMethodID( jclass_NfcRecord, "getSubrecords", "()Lcom/rhomobile/nfc/NfcMessage;");
 
-	logi("native callback TMP 01 java IDs collected");
 
+
+//  private native void callCallback(String callback_url, NfcMessagePack msgpack);
+extern "C" void JNICALL Java_com_rhomobile_nfc_Nfc_callCallback
+(JNIEnv *env, jclass, jstring js_callback_url, jobject jo_msgpack)
+{
+	logi("native callback START");
+
+    initJavaIds(env);
+    
 	CNFCMessagePack* messagePack = new CNFCMessagePack(env, jo_msgpack);
 
-	logi("native callback TMP 02 C++ containers created");
-	
 	char url[2048];
 	char body[2048];
 
@@ -474,17 +1300,12 @@ extern "C" void JNICALL Java_com_rhomobile_nfc_Nfc_callCallback
 	strcpy(url, jurl);
 	env->ReleaseStringUTFChars(js_callback_url, jurl);
 
-	logi("native callback TMP 03 url prepared");
-
 	strcpy(body, "&rho_callback=1");
 	strcat(body, "&");
 	strcat(body, (RHODESAPP().addCallbackObject( new RhoCallbackNFCContainer(messagePack), "messages")).c_str());
 
-	logi("native callback TMP 03+1 body prepared");
-
 	rho_net_request_with_data(rho_http_normalizeurl(url), body);
 
-	logi("native callback FINISH");
 }