initial commit

.gitignore

+*.iml
+.gradle
+/local.properties
+/.idea/caches
+/.idea/libraries
+/.idea/modules.xml
+/.idea/workspace.xml
+/.idea/navEditor.xml
+/.idea/assetWizardSettings.xml
+.DS_Store
+/build
+/captures
+.externalNativeBuild

.idea/encodings.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding" addBOMForNewFiles="with NO BOM" />
+</project>
\ No newline at end of file

.idea/gradle.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <compositeConfiguration>
+          <compositeBuild compositeDefinitionSource="SCRIPT" />
+        </compositeConfiguration>
+        <option name="distributionType" value="DEFAULT_WRAPPED" />
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="resolveModulePerSourceSet" value="false" />
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>
\ No newline at end of file

.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_7" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/build/classes" />
+  </component>
+  <component name="ProjectType">
+    <option name="id" value="Android" />
+  </component>
+</project>
\ No newline at end of file

.idea/runConfigurations.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RunConfigurationProducerService">
+    <option name="ignoredProducers">
+      <set>
+        <option value="org.jetbrains.plugins.gradle.execution.test.runner.AllInPackageGradleConfigurationProducer" />
+        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer" />
+        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer" />
+      </set>
+    </option>
+  </component>
+</project>
\ No newline at end of file

.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

app/.gitignore

+/build

app/build.gradle

+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 28
+    defaultConfig {
+        applicationId "com.kerbol.eeloo"
+        minSdkVersion 18
+        targetSdkVersion 28
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.android.support:appcompat-v7:28.0.0'
+    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
+    testImplementation 'junit:junit:4.12'
+    androidTestImplementation 'com.android.support.test:runner:1.0.2'
+    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
+}

app/proguard-rules.pro

+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

app/src/androidTest/java/com/kerbol/eeloo/ExampleInstrumentedTest.java

+package com.kerbol.eeloo;
+
+import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+    @Test
+    public void useAppContext() {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getTargetContext();
+
+        assertEquals("com.kerbol.eeloo", appContext.getPackageName());
+    }
+}

app/src/main/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.kerbol.eeloo">
+
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme">
+
+        <activity android:name=".MainActivity">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+
+    </application>
+
+</manifest>
\ No newline at end of file

app/src/main/java/com/kerbol/eeloo/MainActivity.java

+package com.kerbol.eeloo;
+
+import android.support.v7.app.AppCompatActivity;
+import android.os.Bundle;
+import android.widget.Button;
+import android.widget.TextView;
+import android.view.View;
+
+public class MainActivity extends AppCompatActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+
+        findViewById(R.id.btnIncR).setOnClickListener(new Button.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                radius_ += 0.01;
+                updateLabels();
+            }
+        });
+        findViewById(R.id.btnDecR).setOnClickListener(new Button.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                radius_ -= 0.01;
+                updateLabels();
+            }
+        });
+        findViewById(R.id.btnIncTheta).setOnClickListener(new Button.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                theta_ += 0.01;
+                updateLabels();
+            }
+        });
+        findViewById(R.id.btnDecTheta).setOnClickListener(new Button.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                theta_ -= 0.01;
+                updateLabels();
+            }
+        });
+        findViewById(R.id.btnIncRho).setOnClickListener(new Button.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                rho_ += 0.01;
+                updateLabels();
+            }
+        });
+        findViewById(R.id.btnDecRho).setOnClickListener(new Button.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                rho_ -= 0.01;
+                updateLabels();
+            }
+        });
+    }
+
+    private void updateLabels()
+    {
+        ((TextView)findViewById(R.id.txtR)).setText("r : " + radius_);
+        ((TextView)findViewById(R.id.txtTheta)).setText("theta : " + theta_);
+        ((TextView)findViewById(R.id.txtRho)).setText("rho : " + rho_);
+    }
+
+    private double radius_ = 1;
+    private double theta_ = 1;
+    private double rho_ = 1;
+}

app/src/main/jni/API/ARDroneGeneratedCommandIn.h

+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// !!!! THIS FILE IS GENERATED AUTOMATICALLY, DO NOT CHANGE IT !!!!
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+/*
+ *  ARDroneGeneratedCommandIn.h
+ *  ARDroneEngine
+ *
+ *  Automatically generated.
+ *  Copyright 2011 Parrot SA. All rights reserved
+ *
+ */
+
+#ifdef COMMAND_IN_CONFIG_KEY
+#ifdef COMMAND_IN_CONFIG_KEY_STRING
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_VIDEO_ENABLE, video_enable, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_CONTROL_LEVEL, control_level, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_EULER_ANGLE_MAX, euler_angle_max, float )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_ALTITUDE_MAX, altitude_max, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_ALTITUDE_MIN, altitude_min, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_CONTROL_IPHONE_TILT, control_iphone_tilt, float )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_CONTROL_VZ_MAX, control_vz_max, float )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_CONTROL_YAW, control_yaw, float )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_OUTDOOR, outdoor, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_FLIGHT_WITHOUT_SHELL, flight_without_shell, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_AUTONOMOUS_FLIGHT, autonomous_flight, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_MANUAL_TRIM, manual_trim, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_INDOOR_EULER_ANGLE_MAX, indoor_euler_angle_max, float )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_INDOOR_CONTROL_VZ_MAX, indoor_control_vz_max, float )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_INDOOR_CONTROL_YAW, indoor_control_yaw, float )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_OUTDOOR_EULER_ANGLE_MAX, outdoor_euler_angle_max, float )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_OUTDOOR_CONTROL_VZ_MAX, outdoor_control_vz_max, float )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_OUTDOOR_CONTROL_YAW, outdoor_control_yaw, float )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_FLYING_MODE, flying_mode, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_HOVERING_RANGE, hovering_range, int )
+COMMAND_IN_CONFIG_KEY_STRING (ARDRONE_CONFIG_KEY_FLIGHT_ANIM, flight_anim )
+COMMAND_IN_CONFIG_KEY_STRING (ARDRONE_CONFIG_KEY_TRAVELLING_MODE, travelling_mode )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_TRAVELLING_ENABLE, travelling_enable, int )
+COMMAND_IN_CONFIG_KEY_STRING (ARDRONE_CONFIG_KEY_SSID_SINGLE_PLAYER, ssid_single_player )
+COMMAND_IN_CONFIG_KEY_STRING (ARDRONE_CONFIG_KEY_SSID_MULTI_PLAYER, ssid_multi_player )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_WIFI_MODE, wifi_mode, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_WIFI_RATE, wifi_rate, int )
+COMMAND_IN_CONFIG_KEY_STRING (ARDRONE_CONFIG_KEY_OWNER_MAC, owner_mac )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_CODEC_FPS, codec_fps, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_VIDEO_CODEC, video_codec, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_VIDEO_SLICES, video_slices, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_VIDEO_LIVE_SOCKET, video_live_socket, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_BITRATE, bitrate, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_MAX_BITRATE, max_bitrate, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_BITRATE_CTRL_MODE, bitrate_ctrl_mode, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_BITRATE_STORAGE, bitrate_storage, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_VIDEO_CHANNEL, video_channel, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_VIDEO_ON_USB, video_on_usb, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_VIDEO_FILE_INDEX, video_file_index, int )
+COMMAND_IN_CONFIG_KEY_STRING (ARDRONE_CONFIG_KEY_LEDS_ANIM, leds_anim )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_ENEMY_COLORS, enemy_colors, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_GROUNDSTRIPE_COLORS, groundstripe_colors, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_ENEMY_WITHOUT_SHELL, enemy_without_shell, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_DETECT_TYPE, detect_type, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_DETECTIONS_SELECT_H, detections_select_h, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_DETECTIONS_SELECT_V_HSYNC, detections_select_v_hsync, int )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_DETECTIONS_SELECT_V, detections_select_v, int )
+COMMAND_IN_CONFIG_KEY_STRING (ARDRONE_CONFIG_KEY_USERBOX_CMD, userbox_cmd )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_LATITUDE, latitude, double )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_LONGITUDE, longitude, double )
+COMMAND_IN_CONFIG_KEY (ARDRONE_CONFIG_KEY_ALTITUDE, altitude, double )
+#endif //COMMAND_IN_CONFIG_KEY_STRING
+#endif //COMMAND_IN_CONFIG_KEY

app/src/main/jni/API/ARDroneGeneratedTypes.h

+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// !!!! THIS FILE IS GENERATED AUTOMATICALLY, DO NOT CHANGE IT !!!!
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+/*
+ *  ARDroneGeneratedTypes.h
+ *  ARDroneEngine
+ *
+ *  Automatically generated.
+ *  Copyright 2010 Parrot SA. All rights reserved.
+ *
+ */
+#ifndef _ARDRONE_GENERATED_TYPES_H_
+#define _ARDRONE_GENERATED_TYPES_H_
+
+#define ARDRONE_MAX_ENEMIES 4
+
+typedef enum {
+ARDRONE_LED_ANIMATION_BLINK_GREEN_RED,
+ARDRONE_LED_ANIMATION_BLINK_GREEN,
+ARDRONE_LED_ANIMATION_BLINK_RED,
+ARDRONE_LED_ANIMATION_BLINK_ORANGE,
+ARDRONE_LED_ANIMATION_SNAKE_GREEN_RED,
+ARDRONE_LED_ANIMATION_FIRE,
+ARDRONE_LED_ANIMATION_STANDARD,
+ARDRONE_LED_ANIMATION_RED,
+ARDRONE_LED_ANIMATION_GREEN,
+ARDRONE_LED_ANIMATION_RED_SNAKE,
+ARDRONE_LED_ANIMATION_BLANK,
+ARDRONE_LED_ANIMATION_RIGHT_MISSILE,
+ARDRONE_LED_ANIMATION_LEFT_MISSILE,
+ARDRONE_LED_ANIMATION_DOUBLE_MISSILE,
+ARDRONE_LED_ANIMATION_FRONT_LEFT_GREEN_OTHERS_RED,
+ARDRONE_LED_ANIMATION_FRONT_RIGHT_GREEN_OTHERS_RED,
+ARDRONE_LED_ANIMATION_REAR_RIGHT_GREEN_OTHERS_RED,
+ARDRONE_LED_ANIMATION_REAR_LEFT_GREEN_OTHERS_RED,
+ARDRONE_LED_ANIMATION_LEFT_GREEN_RIGHT_RED,
+ARDRONE_LED_ANIMATION_LEFT_RED_RIGHT_GREEN,
+ARDRONE_LED_ANIMATION_BLINK_STANDARD,
+} ARDRONE_LED_ANIMATION;
+
+typedef enum {
+ARDRONE_ANIMATION_PHI_M30_DEG=0,
+ARDRONE_ANIMATION_PHI_30_DEG,
+ARDRONE_ANIMATION_THETA_M30_DEG,
+ARDRONE_ANIMATION_THETA_30_DEG,
+ARDRONE_ANIMATION_THETA_20DEG_YAW_200DEG,
+ARDRONE_ANIMATION_THETA_20DEG_YAW_M200DEG,
+ARDRONE_ANIMATION_TURNAROUND,
+ARDRONE_ANIMATION_TURNAROUND_GODOWN,
+ARDRONE_ANIMATION_YAW_SHAKE,
+ARDRONE_ANIMATION_YAW_DANCE,
+ARDRONE_ANIMATION_PHI_DANCE,
+ARDRONE_ANIMATION_THETA_DANCE,
+ARDRONE_ANIMATION_VZ_DANCE,
+ARDRONE_ANIMATION_WAVE,
+ARDRONE_ANIMATION_PHI_THETA_MIXED,
+ARDRONE_ANIMATION_DOUBLE_PHI_THETA_MIXED,
+ARDRONE_ANIMATION_FLIP_AHEAD,
+ARDRONE_ANIMATION_FLIP_BEHIND,
+ARDRONE_ANIMATION_FLIP_LEFT,
+ARDRONE_ANIMATION_FLIP_RIGHT,
+} ARDRONE_ANIMATION;
+
+typedef enum {
+ARDRONE_CAMERA_DETECTION_HORIZONTAL=0,
+ARDRONE_CAMERA_DETECTION_VERTICAL,
+ARDRONE_CAMERA_DETECTION_VISION,
+ARDRONE_CAMERA_DETECTION_NONE,
+ARDRONE_CAMERA_DETECTION_COCARDE,
+ARDRONE_CAMERA_DETECTION_ORIENTED_COCARDE,
+ARDRONE_CAMERA_DETECTION_STRIPE,
+ARDRONE_CAMERA_DETECTION_H_COCARDE,
+ARDRONE_CAMERA_DETECTION_H_ORIENTED_COCARDE,
+ARDRONE_CAMERA_DETECTION_STRIPE_V,
+ARDRONE_CAMERA_DETECTION_MULTIPLE_DETECTION_MODE,
+ARDRONE_CAMERA_DETECTION_CAP,
+ARDRONE_CAMERA_DETECTION_ORIENTED_COCARDE_BW,
+ARDRONE_CAMERA_DETECTION_VISION_V2,
+ARDRONE_CAMERA_DETECTION_TOWER_SIDE,
+ARDRONE_CAMERA_DETECTION_NUM,
+} ARDRONE_CAMERA_DETECTION_TYPE;
+
+typedef enum {
+ARDRONE_VIDEO_CHANNEL_FIRST=0,
+ARDRONE_VIDEO_CHANNEL_HORI=ARDRONE_VIDEO_CHANNEL_FIRST,
+ARDRONE_VIDEO_CHANNEL_VERT,
+ARDRONE_VIDEO_CHANNEL_LARGE_HORI_SMALL_VERT,
+ARDRONE_VIDEO_CHANNEL_LARGE_VERT_SMALL_HORI,
+ARDRONE_VIDEO_CHANNEL_LAST=ARDRONE_VIDEO_CHANNEL_LARGE_VERT_SMALL_HORI,
+ARDRONE_VIDEO_CHANNEL_NEXT,
+} ARDRONE_VIDEO_CHANNEL;
+
+typedef enum {
+ARDRONE_VARIABLE_BITRATE_MODE_DISABLED=0,
+ARDRONE_VARIABLE_BITRATE_MODE_DYNAMIC,
+ARDRONE_VARIABLE_BITRATE_MANUAL
+} ARDRONE_VARIABLE_BITRATE;
+
+typedef enum {
+ARDRONE_ENEMY_COLOR_ORANGE_GREEN=1,
+ARDRONE_ENEMY_COLOR_ORANGE_YELLOW,
+ARDRONE_ENEMY_COLOR_ORANGE_BLUE,
+ARDRONE_ENEMY_COLOR_ARRACE_FINISH_LINE=0x10,
+ARDRONE_ENEMY_COLOR_ARRACE_DONUT=0x11
+} ARDRONE_ENEMY_COLOR;
+
+typedef enum {
+ARDRONE_CONFIG_KEY_VIDEO_ENABLE,//BOOLEAN
+ARDRONE_CONFIG_KEY_CONTROL_LEVEL,//INT
+ARDRONE_CONFIG_KEY_EULER_ANGLE_MAX,//FLOAT
+ARDRONE_CONFIG_KEY_ALTITUDE_MAX,//INT
+ARDRONE_CONFIG_KEY_ALTITUDE_MIN,//INT
+ARDRONE_CONFIG_KEY_CONTROL_IPHONE_TILT,//FLOAT
+ARDRONE_CONFIG_KEY_CONTROL_VZ_MAX,//FLOAT
+ARDRONE_CONFIG_KEY_CONTROL_YAW,//FLOAT
+ARDRONE_CONFIG_KEY_OUTDOOR,//BOOLEAN
+ARDRONE_CONFIG_KEY_FLIGHT_WITHOUT_SHELL,//BOOLEAN
+ARDRONE_CONFIG_KEY_AUTONOMOUS_FLIGHT,//BOOLEAN
+ARDRONE_CONFIG_KEY_MANUAL_TRIM,//BOOLEAN
+ARDRONE_CONFIG_KEY_INDOOR_EULER_ANGLE_MAX,//FLOAT
+ARDRONE_CONFIG_KEY_INDOOR_CONTROL_VZ_MAX,//FLOAT
+ARDRONE_CONFIG_KEY_INDOOR_CONTROL_YAW,//FLOAT
+ARDRONE_CONFIG_KEY_OUTDOOR_EULER_ANGLE_MAX,//FLOAT
+ARDRONE_CONFIG_KEY_OUTDOOR_CONTROL_VZ_MAX,//FLOAT
+ARDRONE_CONFIG_KEY_OUTDOOR_CONTROL_YAW,//FLOAT
+ARDRONE_CONFIG_KEY_FLYING_MODE,//INT
+ARDRONE_CONFIG_KEY_HOVERING_RANGE,//INT
+ARDRONE_CONFIG_KEY_FLIGHT_ANIM,//STRING
+ARDRONE_CONFIG_KEY_TRAVELLING_MODE,//STRING
+ARDRONE_CONFIG_KEY_TRAVELLING_ENABLE,//BOOLEAN
+ARDRONE_CONFIG_KEY_SSID_SINGLE_PLAYER,//STRING
+ARDRONE_CONFIG_KEY_SSID_MULTI_PLAYER,//STRING
+ARDRONE_CONFIG_KEY_WIFI_MODE,//INT
+ARDRONE_CONFIG_KEY_WIFI_RATE,//INT
+ARDRONE_CONFIG_KEY_OWNER_MAC,//STRING
+ARDRONE_CONFIG_KEY_CODEC_FPS,//INT
+ARDRONE_CONFIG_KEY_VIDEO_CODEC,//INT
+ARDRONE_CONFIG_KEY_VIDEO_SLICES,//INT
+ARDRONE_CONFIG_KEY_VIDEO_LIVE_SOCKET,//INT
+ARDRONE_CONFIG_KEY_BITRATE,//INT
+ARDRONE_CONFIG_KEY_MAX_BITRATE,//INT
+ARDRONE_CONFIG_KEY_BITRATE_CTRL_MODE,//INT
+ARDRONE_CONFIG_KEY_BITRATE_STORAGE,//INT
+ARDRONE_CONFIG_KEY_VIDEO_CHANNEL,//INT
+ARDRONE_CONFIG_KEY_VIDEO_ON_USB,//BOOLEAN
+ARDRONE_CONFIG_KEY_VIDEO_FILE_INDEX,//INT
+ARDRONE_CONFIG_KEY_LEDS_ANIM,//STRING
+ARDRONE_CONFIG_KEY_ENEMY_COLORS,//INT
+ARDRONE_CONFIG_KEY_GROUNDSTRIPE_COLORS,//INT
+ARDRONE_CONFIG_KEY_ENEMY_WITHOUT_SHELL,//INT
+ARDRONE_CONFIG_KEY_DETECT_TYPE,//INT
+ARDRONE_CONFIG_KEY_DETECTIONS_SELECT_H,//INT
+ARDRONE_CONFIG_KEY_DETECTIONS_SELECT_V_HSYNC,//INT
+ARDRONE_CONFIG_KEY_DETECTIONS_SELECT_V,//INT
+ARDRONE_CONFIG_KEY_USERBOX_CMD,//STRING
+ARDRONE_CONFIG_KEY_LATITUDE,//DOUBLE
+ARDRONE_CONFIG_KEY_LONGITUDE,//DOUBLE
+ARDRONE_CONFIG_KEY_ALTITUDE,//DOUBLE
+} ARDRONE_CONFIG_KEYS;
+
+typedef enum {
+ARDRONE_VIDEO_CODEC_UVLC = 0x20,
+ARDRONE_VIDEO_CODEC_P264 = 0x40,
+MP4_ARDRONE_VIDEO_CODEC_360P = 0x80,
+H264_ARDRONE_VIDEO_CODEC_360P = 0x81,
+MP4_360P_H264_ARDRONE_VIDEO_CODEC_720P = 0x82,
+H264_ARDRONE_VIDEO_CODEC_720P = 0x83,
+MP4_360P_ARDRONE_VIDEO_CODEC_SLRS = 0x84,
+H264_360P_ARDRONE_VIDEO_CODEC_SLRS = 0x85,
+H264_720P_ARDRONE_VIDEO_CODEC_SLRS = 0x86,
+H264_AUTO_ARDRONE_VIDEO_CODEC_RESIZE = 0x87,
+} ARDRONE_VIDEO_CODEC;
+
+typedef enum {
+ARDRONE_FLYING_MODE_FREE_FLIGHT=0,
+ARDRONE_FLYING_MODE_HOVER_ON_TOP_OF_ROUNDEL=1<<0,
+ARDRONE_FLYING_MODE_HOVER_ON_TOP_OF_ORIENTED_ROUNDEL=1<<1,
+} ARDRONE_FLYING_MODE;
+
+typedef enum {
+ARDRONE_ACADEMY_STATE_NONE,
+ARDRONE_ACADEMY_STATE_CONNECTION,
+ARDRONE_ACADEMY_STATE_PREPARE_PROCESS,
+ARDRONE_ACADEMY_STATE_PROCESS,
+ARDRONE_ACADEMY_STATE_FINISH_PROCESS,
+ARDRONE_ACADEMY_STATE_DISCONNECTION,
+ARDRONE_ACADEMY_STATE_MAX,
+} ARDRONE_ACADEMY_STATE;
+
+typedef enum {
+ARDRONE_ACADEMY_RESULT_NONE,
+ARDRONE_ACADEMY_RESULT_OK,
+ARDRONE_ACADEMY_RESULT_FAILED,
+} ARDRONE_ACADEMY_RESULT;
+
+typedef enum {
+ARDRONE_FLYING_STATE_LANDED=0,
+ARDRONE_FLYING_STATE_FLYING,
+ARDRONE_FLYING_STATE_TAKING_OFF,
+ARDRONE_FLYING_STATE_LANDING,
+} ARDRONE_FLYING_STATE;
+
+#endif // _ARDRONE_GENERATED_TYPES_H_

app/src/main/jni/API/ARDroneTypes.h

+/*
+ *  ARDroneTypes.h
+ *  ARDroneEngine
+ *
+ *  Created by Frédéric D'HAEYER on 21/05/10.
+ *  Copyright 2010 Parrot SA. All rights reserved.
+ *
+ */
+#ifndef _ARDRONE_TYPES_H_
+#define _ARDRONE_TYPES_H_
+#include "ARDroneGeneratedTypes.h"
+
+#define ARDRONE_ADDRESS_SIZE	128
+#define ARDRONE_VERSION_SIZE	128
+
+#define HELVETICA       @"HelveticaNeue-CondensedBold"
+#define WHITE(a)        [UIColor colorWithWhite:1.f alpha:(a)]
+#define BLACK(a)        [UIColor colorWithWhite:0.f alpha:(a)]
+#define ORANGE(a)       [UIColor colorWithRed:255.f/255.f green:120.f/255.f blue:0.f/255.f alpha:(a)]
+
+// Attribute index.
+enum {
+    ARDRONE_ATTRIB_POSITION,
+	ARDRONE_ATTRIB_TEXCOORD,
+    ARDRONE_NUM_ATTRIBUTES
+};
+
+/**
+ * Define the command identifiers from drone to Game Engine
+ */
+typedef enum {
+	ARDRONE_COMMAND_RUN, 
+	ARDRONE_COMMAND_PAUSE, 
+	ARDRONE_COMMAND_FIRE,
+} ARDRONE_COMMAND_OUT;
+
+/**
+ * Define the command identifiers from Game Engine to drone
+ */
+typedef enum {
+	ARDRONE_COMMAND_ISCLIENT,			// Command to set if the multiplayer is client
+	ARDRONE_COMMAND_DRONE_ANIM,			// Command to set a drone animation
+	ARDRONE_COMMAND_DRONE_LED_ANIM,     // Command to set a drone led animation
+	ARDRONE_COMMAND_SET_CONFIG,			// Command to set a drone configuration key
+	ARDRONE_COMMAND_ENABLE_COMBINED_YAW,// Command to enable / disable combined yaw command. 
+	ARDRONE_COMMAND_VIDEO_CHANNEL,		// Command to set the channel of video								-- DEPRECATED
+	ARDRONE_COMMAND_CAMERA_DETECTION,	// Command to set camera type for detection.						-- DEPRECATED
+	ARDRONE_COMMAND_ENEMY_SET_PARAM,	// Command to set enemy parameter for detection (color and hull).	-- DEPRECATED
+	ARDRONE_COMMAND_SET_FLY_MODE,		// Command to change flying mode									-- DEPRECATED
+} ARDRONE_COMMAND_IN;
+
+typedef void (*command_in_configuration_callback)(int result);
+
+/* Define ARDrone information structure */
+typedef struct 
+{
+    char drone_address[ARDRONE_ADDRESS_SIZE];
+    char drone_version[ARDRONE_VERSION_SIZE];
+} ardrone_info_t;
+
+typedef struct
+{
+	ARDRONE_COMMAND_IN command;
+	command_in_configuration_callback callback;
+	void *parameter;
+} ARDRONE_COMMAND_IN_WITH_PARAM;
+
+typedef struct
+{
+	ARDRONE_ENEMY_COLOR color;
+	int outdoor_shell;			// 1 if enemy has outdoor shell, else 0 
+} ARDRONE_ENEMY_PARAM;
+
+typedef struct
+{
+	ARDRONE_LED_ANIMATION led_anim;
+	float frequency;
+	unsigned int duration;
+} ARDRONE_LED_ANIMATION_PARAM;
+
+typedef struct
+{
+	ARDRONE_ANIMATION drone_anim;
+	int timeout;
+} ARDRONE_ANIMATION_PARAM;
+
+/* Comments are used for autogeneration
+ * Do not modify these !
+ */
+// MATCH_TYPES : int : int32_t bool_t
+// MATCH_TYPES : unsigned int : uint32_t
+// MATCH_TYPES : float : float32_t
+// MATCH_TYPES : double : float64_t
+/* End of autogeneration comments */
+
+typedef struct
+{
+	ARDRONE_CONFIG_KEYS config_key;
+	void *pvalue;
+} ARDRONE_CONFIG_PARAM;
+
+/**
+ * Define what a 3D vector is
+ */
+typedef struct
+{
+	float x;
+	float y;
+	float z;
+}
+ARDroneVector3D;
+
+/**
+ * Define a structure to collect drone's navigation data
+ */
+typedef struct
+{
+	/**
+	 * Translation speed of the drone, in meters per second
+	 */
+	ARDroneVector3D linearVelocity;
+	
+	/**
+	 * Rotation speed of the drone, in degré
+	 */
+	ARDroneVector3D angularPosition;
+	
+	/**
+	 * Navdata video num frames to synchronized Navdata with video
+	 */
+	int navVideoNumFrames;
+	
+	/**
+	 * Video num frames to synchronized Navdata with video
+	 */
+	int videoNumFrames;
+	
+	/**
+	 * Value indicates drone flying state (see ARDRONE_FLYING_STATE enum) 
+	 */
+	ARDRONE_FLYING_STATE flyingState;
+	
+	/**
+	 * int indicates drone is in emergency state  (1 if is in emergency, 0 else)
+	 */
+	int emergencyState;
+	
+	/**
+	 * Camera detection type
+	 */
+	ARDRONE_CAMERA_DETECTION_TYPE detection_type;
+	
+	/**
+	 * Number of finish lines detected
+	 */
+	unsigned int finishLineCount;
+	
+	/**
+	 * Number of double taps detected
+	 */
+	unsigned int doubleTapCount;
+    
+    /**
+     * Tells the application that the ardrone engine is done with initial configuration so the application can send their own configs
+     * (1 if application can send config, 0 otherwise)
+     */
+    int isInit;
+}
+ARDroneNavigationData;
+
+/**
+ * Define a structure to exchange an enemy data
+ */
+typedef struct
+{
+	/**
+	 * Position of the enemy (between -1.0 and 1.0)
+	 */
+	ARDroneVector3D position;
+	
+	/**
+	 * Size of the enemy (between 0.0 and 2.0)
+	 */
+	float height, width;
+	
+	/**
+	 * Angle of the enemy (between -90.0° and 90.0°)
+	 */
+	float orientation_angle;
+}
+ARDroneEnemyData;
+
+/**
+ * Define a structure to exchange camera parameters compute by detection
+ */
+typedef struct
+{
+	/**
+	 * Rotation matrix of camera
+	 */
+	float rotation[3][3];
+	
+	/**
+	 * Translation matrix of camera
+	 */
+	float translation[3];
+	
+	/**
+	 * Index of tag detected
+	 */
+	int tag_index;
+} 
+ARDroneDetectionCamera;
+
+/**
+ * Define a structure to exchange camera parameters compute by drone
+ */
+typedef struct
+{
+	/**
+	 * Rotation matrix of camera
+	 */
+	float rotation[3][3];
+	
+	/**
+	 * Translation matrix of camera
+	 */
+	float translation[3];
+} 
+ARDroneCamera;
+
+/**
+ * Define a structure to exchange all enemies data
+ */
+typedef struct
+{
+	/**
+	 * Number of enemies
+	 */
+	unsigned int count;
+	
+	/**
+	 * Pointer to an array that contains the data structure of each enemy
+	 */
+	ARDroneEnemyData data[ARDRONE_MAX_ENEMIES];
+}
+ARDroneEnemiesData;
+
+#endif // _ARDRONE_TYPES_H_

app/src/main/jni/API/Android.mk

+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE    := sdk 
+LOCAL_SRC_FILES := libsdk.a
+
+include $(PREBUILT_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE    := pc_ardrone 
+LOCAL_SRC_FILES := libpc_ardrone.a
+
+include $(PREBUILT_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE    := vlib 
+LOCAL_SRC_FILES := libvlib.a
+
+include $(PREBUILT_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)  
+
+LOCAL_CFLAGS += -I$(SDK_PATH)
+LOCAL_CFLAGS += -I$(SDK_PATH)/Soft/Common
+LOCAL_CFLAGS += -I$(SDK_PATH)/Soft/Lib
+LOCAL_CFLAGS += -I$(SDK_PATH)/VLIB
+LOCAL_CFLAGS += -I$(SDK_PATH)/VLIB/Platform/arm9
+LOCAL_CFLAGS += -I$(SDK_PATH)/VP_SDK
+LOCAL_CFLAGS += -I$(SDK_PATH)/VP_SDK/VP_Com/linux
+LOCAL_CFLAGS += -I$(SDK_PATH)/VP_SDK/VP_Com
+LOCAL_CFLAGS += -I$(SDK_PATH)/VP_SDK/VP_Os
+LOCAL_CFLAGS += -I$(SDK_PATH)/VP_SDK/VP_Os/linux
+LOCAL_CFLAGS += -I$(SDK_PATH)/VP_SDK/VP_Com/linux
+
+LOCAL_C_INCLUDES:=	$(LOCAL_PATH)/../ITTIAM/avc_decoder/includes \
+					$(LOCAL_PATH)/../ITTIAM/m4v_decoder/includes \
+					$(LOCAL_PATH)/../FFMPEG/Includes
+#LIB_PATH=$(LOCAL_PATH)/../../libs/armeabi
+
+LOCAL_LDLIBS := -llog -lGLESv2 -ljnigraphics
+
+LOCAL_MODULE    := adfreeflight  
+
+LOCAL_SRC_FILES := app.c \
+				video_stage_io_file.c \
+				hardware_capabilites.c \
+				Controller/ardrone_controller.c \
+				ControlData.c \
+				Callbacks/drone_proxy_callbacks.c \
+				Callbacks/java_callbacks.c \
+				Plf/plf.c \
+				Stubs/drone_stub.c \
+				Stubs/drone_config_stub.c \
+				Stubs/ftp_client_stub.c \
+				Stubs/plf_file_stub.c \
+				Stubs/transcoding_service_stub.c \
+				Stubs/gl_bg_video_sprite_stub.c \
+				NavData/nav_data.c \
+				Video/video_stage_renderer.c \
+				Video/frame_rate.c \
+				Controller/virtual_gamepad.c \
+				Video/opengl_stage.c \
+				Video/opengl_shader.c 
+
+LOCAL_STATIC_LIBRARIES := pc_ardrone vlib sdk ittiam_avc_decoder ittiam_m4v_decoder ittiam_decoder_utils
+LOCAL_SHARED_LIBRARIES := AVUTIL-prebuilt AVCODEC-prebuilt SWSCALE-prebuilt AVFILTER-prebuilt AVFORMAT-prebuilt AVDEVICE-prebuilt
+
+LOCAL_CFLAGS += -D__USE_GNU -D__linux__ -DNO_ARDRONE_MAINLOOP -DUSE_ANDROID -DTARGET_CPU_ARM=1 -DTARGET_CPU_X86=0 -DUSE_WIFI -DFFMPEG_SUPPORT -fstack-protector
+LOCAL_CFLAGS += -DANDROID_NDK
+#LOCAL_LDFLAGS := -Wl,-Map,app.map
+
+include $(BUILD_SHARED_LIBRARY)
+

app/src/main/jni/API/Callbacks/drone_proxy_callbacks.c

+/*
+ * drone_proxy_callback.c
+ *
+ *  Created on: May 10, 2011
+ *      Author: Dmytro Baryskyy
+ */
+
+#include "../common.h"
+#include "java_callbacks.h"
+#include "drone_proxy_callbacks.h"
+
+static const char* TAG = "DRONE_PROXY_CALLBACK";
+
+void parrot_drone_proxy_onConnected(JNIEnv* env, jobject obj)
+{
+	parrot_java_callbacks_call_void_method(env, obj, "onConnected");
+}
+
+
+void parrot_drone_proxy_onDisconnected(JNIEnv* env, jobject obj)
+{
+	parrot_java_callbacks_call_void_method(env, obj, "onDisconnected");
+}
+
+
+void parrot_drone_proxy_onConnectionFailed(JNIEnv* env, jobject obj, int code)
+{
+	if (env == NULL) {
+		return;
+	}
+
+	jclass cls = (*env)->GetObjectClass(env, obj);
+	jmethodID mid = (*env)->GetMethodID(env, cls, "onConnectionFailed", "(I)V");
+	jint jcode = code;
+
+	if (mid == 0) {
+		LOGW(TAG, "Method not found");
+		return;
+	}
+
+	(*env)->CallVoidMethod(env, obj, mid, jcode);
+
+	(*env)->DeleteLocalRef(env, cls);
+}
+
+
+void parrot_drone_proxy_onConfigChanged(JNIEnv* env, jobject obj)
+{
+	parrot_java_callbacks_call_void_method(env, obj, "onConfigChanged");
+}
+
+

app/src/main/jni/API/Callbacks/drone_proxy_callbacks.h

+/*
+ * drone_proxy_callbacks.h
+ *
+ *  Created on: May 7, 2011
+ *      Author: Dmytro Baryskyy
+ */
+
+#ifndef DRONE_PROXY_CALLBACKS_H_
+#define DRONE_PROXY_CALLBACKS_H_
+
+// These callbacks are called by the native code and the control will go to the Java
+extern void parrot_drone_proxy_onConnected       (JNIEnv* env, jobject /*obj*/);
+extern void parrot_drone_proxy_onConnectionFailed(JNIEnv* env, jobject /*obj*/, int /*code*/);
+extern void parrot_drone_proxy_onDisconnected    (JNIEnv* env, jobject /*obj*/);
+extern void parrot_drone_proxy_onConfigChanged   (JNIEnv* env, jobject /*obj*/);
+extern void ardrone_academy_callback_called      (const char* mediaPath, bool_t addToQueue);
+
+#endif /* DRONE_PROXY_CALLBACKS_H_ */

app/src/main/jni/API/Callbacks/java_callbacks.c

+/*
+ * java_callbacks.c
+ *
+ *  Created on: Jan 31, 2012
+ *      Author: "Dmytro Baryskyy"
+ */
+
+#include "common.h"
+#include "java_callbacks.h"
+
+static const char* TAG = "JAVA_CALLBACKS";
+
+void parrot_java_callbacks_call_void_method(JNIEnv *env, jobject obj, const char* methodName)
+{
+	if (env == NULL || obj == NULL) {
+		LOGW(TAG, "env or obj is null");
+		return;
+	}
+
+	jclass cls = (*env)->GetObjectClass(env, obj);
+	jmethodID mid = (*env)->GetMethodID(env, cls, methodName, "()V");
+
+	if (mid == 0) {
+		LOGW(TAG, "Method not found");
+		return;
+	}
+
+	(*env)->CallVoidMethod(env, obj, mid);
+
+	(*env)->DeleteLocalRef(env, cls);
+}
+
+
+void parrot_java_callbacks_call_void_method_int_int(jobject obj, const char* methodName, int param1, int param2)
+{
+	JNIEnv* env = NULL;
+
+	if (g_vm != NULL)
+	{
+		(*g_vm)->GetEnv(g_vm, (void **)&env, JNI_VERSION_1_6);
+	}
+
+	if (env == NULL || obj == NULL) {
+		LOGW(TAG, "env or obj is null");
+		return;
+	}
+
+	jclass cls = (*env)->GetObjectClass(env, obj);
+	jmethodID mid = (*env)->GetMethodID(env, cls, methodName, "(II)V");
+
+	if (mid == 0) {
+		LOGW(TAG, "Method not found");
+		return;
+	}
+
+	(*env)->CallVoidMethod(env, obj, mid, param1, param2);
+
+	(*env)->DeleteLocalRef(env, cls);
+}
+
+
+void parrot_java_callbacks_call_void_method_string(JNIEnv *env, jobject obj, const char*methodName, const char* param)
+{
+	if (env == NULL || obj == NULL) {
+		LOGW(TAG, "env or obj is null");
+		return;
+	}
+
+	jclass cls = (*env)->GetObjectClass(env, obj);
+	jmethodID mid = (*env)->GetMethodID(env, cls, methodName, "(Ljava/lang/String;)V");
+
+	if (mid == 0) {
+		LOGW(TAG, "Method not found");
+		return;
+	}
+
+	jstring paramUrf8 = (*env)->NewStringUTF(env, param);
+
+	(*env)->CallVoidMethod(env, obj, mid, paramUrf8);
+	(*env)->DeleteLocalRef(env, cls);
+}
+
+void parrot_java_callbacks_call_void_method_string_boolean(JNIEnv *env, jobject obj, const char*methodName, const char* param, bool_t param2)
+{
+	if (env == NULL || obj == NULL) {
+		LOGW(TAG, "env or obj is null");
+		return;
+	}
+
+	jclass cls = (*env)->GetObjectClass(env, obj);
+	jmethodID mid = (*env)->GetMethodID(env, cls, methodName, "(Ljava/lang/String;Z)V");
+
+	if (mid == 0) {
+		LOGW(TAG, "Method not found");
+		return;
+	}
+
+	jstring paramUrf8 = (*env)->NewStringUTF(env, param);
+
+    jboolean boolJava = param2;
+
+	(*env)->CallVoidMethod(env, obj, mid, paramUrf8, boolJava);
+	(*env)->DeleteLocalRef(env, cls);
+}
+
+void java_set_field_int(JNIEnv *env, jobject obj, const char* fieldName, jint value)
+{
+	jclass class = (*env)->GetObjectClass(env, obj);
+
+	jfieldID fieldId  = (*env)->GetFieldID(env, class, fieldName,  "I");
+	(*env)->SetIntField(env, obj, fieldId, value);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, class);
+}
+
+
+void java_set_field_bool(JNIEnv *env, jobject obj, const char* fieldName, jboolean value)
+{
+	jclass class = (*env)->GetObjectClass(env, obj);
+
+	jfieldID fieldId  = (*env)->GetFieldID(env, class, fieldName,  "Z");
+	(*env)->SetBooleanField(env, obj, fieldId, value);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, class);
+}
+
+
+jboolean java_get_bool_field_value(JNIEnv *env, jobject obj, const char* fieldName)
+{
+	jclass class = (*env)->GetObjectClass(env, obj);
+
+	jfieldID fieldId = (*env)->GetFieldID(env, class, fieldName, "Z");
+	jboolean value = (*env)->GetBooleanField(env, obj, fieldId);
+
+	(*env)->DeleteLocalRef(env, class);
+
+	return value;
+}
+

app/src/main/jni/API/Callbacks/java_callbacks.h

+/*
+ * java_callbacks.h
+ *
+ *  Created on: Jan 31, 2012
+ *      Author: "Dmytro Baryskyy"
+ */
+
+#ifndef JAVA_CALLBACKS_H_
+#define JAVA_CALLBACKS_H_
+
+extern void parrot_java_callbacks_call_void_method(JNIEnv *env, jobject obj, const char* methodName);
+extern void parrot_java_callbacks_call_void_method_int_int(jobject obj, const char* methodName, int param1, int param2);
+extern void parrot_java_callbacks_call_void_method_string(JNIEnv* env, jobject obj, const char*methodName, const char* param);
+extern void java_set_field_int(JNIEnv *env, jobject obj, const char* fieldName, jint value);
+extern void java_set_field_bool(JNIEnv *env, jobject obj, const char* fieldName, jboolean value);
+extern jboolean java_get_bool_field_value(JNIEnv *env, jobject obj, const char* fieldName);
+#endif /* JAVA_CALLBACKS_H_ */

app/src/main/jni/API/ControlData.c

+/*
+ *  ControlData.m
+ *  ARDroneEngine
+ *
+ *  Created by Frederic D'HAEYER on 14/01/10.
+ *  Copyright 2010 Parrot SA. All rights reserved.
+ *
+ */
+#include "common.h"
+#include <ardrone_tool/Navdata/ardrone_academy_navdata.h>
+#include <VLIB/video_codec.h>
+#include "ControlData.h"
+
+//#define DEBUG_CONTROL
+
+ControlData ctrldata;
+
+static const char* TAG = "ControlData";
+
+void setApplicationDefaultConfig()
+{
+    videoCapabilities vCaps = getDeviceVideoCapabilites ();
+#ifdef DEBUG_CONTROL
+    printDeviceInfos();
+#endif
+	ardrone_application_default_config.navdata_demo = TRUE;
+    ardrone_application_default_config.navdata_options = (NAVDATA_OPTION_MASK(NAVDATA_DEMO_TAG) | NAVDATA_OPTION_MASK(NAVDATA_VISION_DETECT_TAG) | NAVDATA_OPTION_MASK(NAVDATA_GAMES_TAG) | NAVDATA_OPTION_MASK(NAVDATA_MAGNETO_TAG) | NAVDATA_OPTION_MASK(NAVDATA_HDVIDEO_STREAM_TAG) | NAVDATA_OPTION_MASK(NAVDATA_WIFI_TAG));
+
+    if (IS_ARDRONE2)
+    {
+        ardrone_application_default_config.codec_fps = vCapsInfo[vCaps].supportedFps;
+        ardrone_application_default_config.max_bitrate = vCapsInfo[vCaps].supportedBitrate;
+        ardrone_application_default_config.video_codec = vCapsInfo[vCaps].defaultCodec;
+#ifdef DEBUG_CONTROL
+        LOGD ("CONTROL_DATA", "Device support : %d fps @ %d kbps - codec value : 0x%02x\n", vCapsInfo[vCaps].supportedFps, vCapsInfo[vCaps].supportedBitrate, vCapsInfo[vCaps].defaultCodec);
+#endif
+        ardrone_application_default_config.bitrate_ctrl_mode = ARDRONE_VARIABLE_BITRATE_MODE_DYNAMIC;
+    } else {
+        ardrone_application_default_config.video_codec = P264_CODEC;
+        ardrone_application_default_config.bitrate_ctrl_mode = ARDRONE_VARIABLE_BITRATE_MODE_DYNAMIC;        
+    }
+
+    switch (ctrldata.recordingCapability) {
+    case VIDEO_RECORDING_NOT_SUPPORTED:
+    	ardrone_academy_navdata_set_wifi_record_codec(NULL_CODEC);
+    	break;
+    case VIDEO_RECORDING_360P:
+        ardrone_academy_navdata_set_wifi_record_codec(MP4_360P_H264_360P_CODEC);
+    	break;
+    case VIDEO_CAPABILITIES_720:
+    	ardrone_academy_navdata_set_wifi_record_codec(MP4_360P_H264_720P_CODEC);
+    	break;
+    }
+
+    LOGD(TAG, "setApplicationDefaultConfig [OK]");
+}
+
+
+void initControlData(void)
+{
+	ctrldata.framecounter = 0;
+	
+	ctrldata.needAnimation = FALSE;
+	vp_os_memset(ctrldata.needAnimationParam, 0, sizeof(ctrldata.needAnimationParam));
+	
+	ctrldata.needVideoSwitch = -1;
+	
+	ctrldata.needLedAnimation = FALSE;
+	vp_os_memset(ctrldata.needLedAnimationParam, 0, sizeof(ctrldata.needLedAnimationParam));
+	
+	resetControlData();
+	ardrone_tool_input_start_reset();
+	
+//	navdata_write_to_file(FALSE);
+    
+    ctrldata.navdata_connected = FALSE;
+
+    LOGD(TAG, "initControlData [OK]");
+}
+
+void resetControlData(void)
+{
+	//printf("reset control data\n");
+	ctrldata.command_flag = 0;
+	inputPitch(0.0);
+	inputRoll(0.0);
+	inputYaw(0.0);
+	inputGaz(0.0);
+    ctrldata.iphone_psi = 0;
+    ctrldata.iphone_psi_accuracy = 0;
+}
+
+void inputYaw(float percent)
+{
+#ifdef DEBUG_CONTROL
+	LOGD ("CONTROL_DATA", "%s : %f\n", __FUNCTION__, percent);
+#endif
+	if(-1.0f <= percent && percent <= 1.0f)
+		ctrldata.yaw = percent;
+	else if(-1.0f > percent)
+		ctrldata.yaw = -1.0f;
+	else
+		ctrldata.yaw = 1.0f;
+}
+
+void inputGaz(float percent)
+{
+#ifdef DEBUG_CONTROL
+	LOGD ("CONTROL_DATA", "%s : %f\n", __FUNCTION__, percent);
+#endif
+	if(-1.0f <= percent && percent <= 1.0f)
+		ctrldata.gaz = percent;
+	else if(-1.0f > percent)
+		ctrldata.gaz = -1.0f;
+	else
+		ctrldata.gaz = 1.0f;
+}
+
+void inputPitch(float percent)
+{
+#ifdef DEBUG_CONTROL
+	LOGD ("CONTROL_DATA", "%s : %f, accelero_enable : %d\n", __FUNCTION__, percent, (ctrldata.command_flag >> ARDRONE_PROGRESSIVE_CMD_ENABLE) & 0x1 );
+#endif
+	if(-1.0f <= percent && percent <= 1.0f)
+		ctrldata.iphone_theta = percent;
+	else if(-1.0f > percent)
+		ctrldata.iphone_theta = -1.0f;
+	else
+		ctrldata.iphone_theta = 1.0f;
+
+#ifdef DEBUG_CONTROL
+	LOGD ("CONTROL_DATA", "%s : %f, accelero_enable : %d\n", __FUNCTION__, ctrldata.iphone_theta, (ctrldata.command_flag >> ARDRONE_PROGRESSIVE_CMD_ENABLE) & 0x1 );
+#endif
+}
+
+void inputRoll(float percent)
+{
+#ifdef DEBUG_CONTROL
+	LOGD ("CONTROL_DATA", "%s : %f, accelero_enable : %d\n", __FUNCTION__, percent, (ctrldata.command_flag >> ARDRONE_PROGRESSIVE_CMD_ENABLE) & 0x1);
+#endif
+	if(-1.0f <= percent && percent <= 1.0f)
+		ctrldata.iphone_phi = percent;
+	else if(-1.0f > percent)
+		ctrldata.iphone_phi = -1.0f;
+	else
+		ctrldata.iphone_phi = 1.0f;
+
+#ifdef DEBUG_CONTROL
+	LOGD ("CONTROL_DATA", "%s : %f, accelero_enable : %d\n", __FUNCTION__, ctrldata.iphone_phi, (ctrldata.command_flag >> ARDRONE_PROGRESSIVE_CMD_ENABLE) & 0x1 );
+	LOGD ("CONTROL_DATA", "ARDRONE_PROGRESSIVE_CMD_ENABLE: %d ARDRONE_PROGRESSIVE_CMD_COMBINED_YAW_ACTIVE : %d\ ",  (ctrldata.command_flag >> ARDRONE_PROGRESSIVE_CMD_ENABLE) & 0x1 , (ctrldata.command_flag >> ARDRONE_PROGRESSIVE_CMD_COMBINED_YAW_ACTIVE) & 0x1 );
+#endif
+}
+
+void set_command_flag(int flag, bool_t enabled)
+{
+	if (enabled == TRUE) {
+		ctrldata.command_flag |= (1 << flag);
+	} else {
+		ctrldata.command_flag &= ~(1 << flag);
+	}
+}
+
+void sendControls(void)
+{
+    ardrone_tool_set_progressive_cmd(ctrldata.command_flag, ctrldata.iphone_phi, ctrldata.iphone_theta, ctrldata.gaz, ctrldata.yaw, ctrldata.iphone_psi, ctrldata.iphone_psi_accuracy);
+}
+

app/src/main/jni/API/ControlData.h

+/*
+ *  ControlData.h
+ *  ARDroneEngine
+ *
+ *  Created by Frederic D'HAEYER on 14/01/10.
+ *  Copyright 2010 Parrot SA. All rights reserved.
+ *
+ */
+#ifndef _CONTROLDATA_H_
+#define _CONTROLDATA_H_
+#include "common.h"
+
+#define SMALL_STRING_SIZE	16
+#define MEDIUM_STRING_SIZE	64
+
+typedef enum _CONFIG_STATE_
+{
+	CONFIG_STATE_IDLE,
+	CONFIG_STATE_NEEDED,
+	CONFIG_STATE_IN_PROGRESS,
+} CONFIG_STATE;	
+
+typedef struct
+{
+	float64_t latitude;
+	float64_t longitude;
+	float64_t altitude;
+} gps_info_t;
+
+typedef struct 
+{
+	/**
+	 * Progressive commands
+	 * And accelerometers values transmitted to drone, FALSE otherwise
+	 */
+	float yaw, gaz, iphone_phi, iphone_theta, iphone_psi, iphone_psi_accuracy;
+	int32_t command_flag;
+	
+	int framecounter;
+
+	int needVideoSwitch;
+
+	bool_t needAnimation;
+	char needAnimationParam[SMALL_STRING_SIZE];
+	
+	bool_t needLedAnimation;
+	char needLedAnimationParam[SMALL_STRING_SIZE];
+    
+    bool_t navdata_connected;
+
+    VIDEO_RECORDING_CAPABILITY recordingCapability;
+
+} ControlData;
+
+void initControlData(void);
+void resetControlData(void);
+void setApplicationDefaultConfig(void);
+void setMagnetoEnabled(bool_t enabled);
+void set_command_flag(int flag, bool_t enabled);
+void getConfigSuccess(bool_t result);
+void inputYaw(float percent);
+void inputGaz(float percent);
+void inputPitch(float percent);
+void inputRoll(float percent);
+void sendControls(void);
+
+#endif // _CONTROLDATA_H_

app/src/main/jni/API/Controller/ardrone_controller.c

+/*
+ * ardrone_controller.c
+ *
+ *  Created on: Apr 10, 2011
+ *      Author: Dmytro Baryskyy
+ */
+
+// Ardrone Library
+#include <ardrone_api.h>
+
+#include "common.h"
+#include "ControlData.h"
+#include "../NavData/nav_data.h"
+#include "virtual_gamepad.h"
+#include "ARDroneGeneratedTypes.h"
+#include "ardrone_controller.h"
+
+static const char* TAG = "ARDRONE_CONTROLLER";
+
+// Local helper methods
+static bool_t get_state_from_mask(uint32_t state, CTRL_STATES value);
+static bool_t is_power_param_valid(float32_t power);
+static int channel = ARDRONE_VIDEO_CHANNEL_FIRST;
+
+
+extern ControlData ctrldata;
+
+void parrot_ardrone_ctrl_take_off()
+{
+	ardrone_academy_navdata_takeoff();
+}
+
+void parrot_ardrone_ctrl_emergency()
+{
+	ardrone_academy_navdata_emergency();
+}
+
+
+void parrot_ardrone_ctrl_set_command_flag(int32_t control_mode, bool_t enable)
+{
+	set_command_flag(control_mode, enable);
+}
+
+
+void parrot_ardrone_ctrl_set_yaw(float32_t percent)
+{
+	inputYaw(percent);
+}
+
+
+void parrot_ardrone_ctrl_set_gaz(float32_t percent)
+{
+	inputGaz(percent);
+}
+
+
+void parrot_ardrone_ctrl_set_roll(float32_t percent)
+{
+	inputRoll(percent);
+}
+
+
+void parrot_ardrone_ctrl_set_pitch(float32_t percent)
+{
+	inputPitch(percent);
+}
+
+
+bool_t parrot_ardrone_ctrl_has_ctrl_status(CTRL_STATES value)
+{
+	//return get_state_from_mask(instance_navdata.current_control_state, value);
+	return FALSE;
+}
+
+//
+uint32_t parrot_ardrone_ctrl_get_battery_level()
+{
+//	return instance_navdata.battery_level;
+}
+
+
+uint32_t parrot_ardrone_ctrl_get_altitude()
+{
+	uint32_t altitude = 0;
+//	altitude = instance_navdata.altitude;
+
+	return altitude;
+}
+
+
+void parrot_ardrone_ctrl_set_yaw_max_angle(float32_t max_angle)
+{
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(control_yaw, &max_angle, NULL);
+}
+
+
+void parrot_ardrone_ctrl_set_tilt_max_angle(float32_t max_angle)
+{
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(euler_angle_max, &max_angle, NULL);
+}
+
+
+void parrot_ardrone_ctrl_set_vert_speed_max(float32_t speed)
+{
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(control_vz_max, &speed, NULL);
+}
+
+
+void parrot_ardrone_ctrl_switch_camera(ardrone_tool_configuration_callback callback)
+{
+	if(channel++ == ARDRONE_VIDEO_CHANNEL_LAST)
+				channel = ARDRONE_VIDEO_CHANNEL_FIRST;
+
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(video_channel, (int32_t*)&channel, callback);
+}
+
+
+void parrot_ardrone_ctrl_set_flat_trim()
+{
+	ardrone_at_set_flat_trim();
+}
+
+
+float32_t parrot_ardrone_ctrl_get_yaw_max_angle()
+{
+	return ardrone_control_config.control_yaw;
+}
+
+
+float32_t parrot_ardrone_ctrl_get_tilt_max_angle()
+{
+	return ardrone_control_config.euler_angle_max;
+}
+
+
+float32_t parrot_ardrone_ctrl_get_vert_speed_max()
+{
+	return ardrone_control_config.control_vz_max;;
+}
+
+
+bool_t parrot_ardrone_ctrl_is_outdoor_mode()
+{
+	return ardrone_control_config.outdoor;
+}
+
+
+void parrot_ardrone_ctrl_set_outdoor_mode(bool_t outdoor, ardrone_tool_configuration_callback callback)
+{
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(outdoor, &outdoor, NULL);
+}
+
+
+bool_t get_state_from_mask(uint32_t state, CTRL_STATES value)
+{
+	uint32_t major = state >> 16;
+
+	return (major == value?TRUE:FALSE);
+}
+
+
+bool_t is_power_param_valid(float32_t power)
+{
+	if (power >= 0.0f && power <=1.0f) {
+		return TRUE;
+	}
+
+	LOGW(TAG, "Invalid power parameter : %f", power);
+	return FALSE;
+}

app/src/main/jni/API/Controller/ardrone_controller.h

+/*
+ * ardrone_controller.h
+ *
+ *  Created on: Apr 10, 2011
+ *      Author: Dmytro Baryskyy
+ */
+
+#ifndef ARDRONE_CONTROLLER_H_
+#define ARDRONE_CONTROLLER_H_
+
+#include <control_states.h>
+#include <ardrone_tool/UI/ardrone_input.h>
+#include <ardrone_tool/ardrone_tool_configuration.h>
+
+void parrot_ardrone_ctrl_take_off();
+void parrot_ardrone_ctrl_land();
+void parrot_ardrone_ctrl_emergency();
+void parrot_ardrone_ctrl_emergency_clear();
+
+// Functions that used to set the options
+void parrot_ardrone_ctrl_set_yaw_max_angle (float32_t /*max_angle*/); //in radians
+void parrot_ardrone_ctrl_set_tilt_max_angle(float32_t /*max_angle*/); //in radians
+void parrot_ardrone_ctrl_set_vert_speed_max(float32_t /*speed*/); //in mm per second
+void parrot_ardrone_ctrl_set_flat_trim();
+void parrot_ardrone_ctrl_set_outdoor_mode(bool_t /*outdoor*/, ardrone_tool_configuration_callback /*callback*/);
+
+
+void parrot_ardrone_ctrl_set_command_flag(int32_t /*control_mode*/, bool_t /*enable*/);
+// Functions that controls gaz, yaw, roll and pitch
+void parrot_ardrone_ctrl_set_yaw  (float32_t /*yaw*/);
+void parrot_ardrone_ctrl_set_gaz  (float32_t /*gaz*/);
+void parrot_ardrone_ctrl_set_roll (float32_t /*roll*/);
+void parrot_ardrone_ctrl_set_pitch(float32_t /*pitch*/);
+
+// Functions that control video
+void parrot_ardrone_ctrl_switch_camera(ardrone_tool_configuration_callback /*callback*/);
+
+bool_t    parrot_ardrone_ctrl_has_ctrl_status(CTRL_STATES /*state*/);
+uint32_t  parrot_ardrone_ctrl_get_battery_level();
+uint32_t  parrot_ardrone_ctrl_get_altitude();
+float32_t parrot_ardrone_ctrl_get_yaw_max_angle();
+float32_t parrot_ardrone_ctrl_get_tilt_max_angle();
+float32_t parrot_ardrone_ctrl_get_vert_speed_max();
+bool_t    parrot_ardrone_ctrl_is_outdoor_mode();
+
+#endif /* ARDRONE_CONTROLLER_H_ */

app/src/main/jni/API/Controller/virtual_gamepad.c

+/*
+ * virtual_gamepad.c
+ *
+ *  Created on: May 13, 2011
+ *      Author: Dmytro Baryskyy
+ */
+
+#include <VP_Os/vp_os_print.h>
+
+#include <ardrone_tool/UI/ardrone_input.h>
+
+#include "common.h"
+#include "ControlData.h"
+#include "virtual_gamepad.h"
+
+// Defining callbacks for the virtual gamepad
+input_device_t virtual_gamepad = {
+  "Virtual Gamepad",
+  open_gamepad,
+  update_gamepad,
+  close_gamepad
+};
+
+static const char* TAG = "VIRTUAL_GAMEPAD";
+
+
+// Will be called once
+C_RESULT open_gamepad(void)
+{
+	LOGI (TAG, "GAMEPAD OPEN CALLED");
+	return C_OK;
+}
+
+
+// Will be called approx 30 times per second
+C_RESULT update_gamepad(void)
+{
+	sendControls();
+
+	return C_OK;
+}
+
+
+C_RESULT close_gamepad(void)
+{
+	LOGI (TAG, "GAMEPAD CLOSE CALLED");
+	return C_OK;
+}

app/src/main/jni/API/Controller/virtual_gamepad.h

+/*
+ * virtual_gamepad.h
+ *
+ *  Created on: May 13, 2011
+ *      Author: Dmytro Baryskyy
+ */
+
+#ifndef VIRTUAL_GAMEPAD_H_
+#define VIRTUAL_GAMEPAD_H_
+
+
+#include <ardrone_tool/UI/ardrone_input.h>
+
+// Setting virtual gamepad callbacks
+extern input_device_t virtual_gamepad;
+
+// Gamepad callbacks
+static C_RESULT open_gamepad(void);
+static C_RESULT update_gamepad(void);
+static C_RESULT close_gamepad(void);
+
+
+#endif /* VIRTUAL_GAMEPAD_H_ */

app/src/main/jni/API/NavData/nav_data.c

+/*
+ * nav_data.c
+ *
+ *  Created on: May 13, 2011
+ *      Author: "Dmytro Baryskyy"
+ */
+
+// VP_Os Library
+#include <VP_Os/vp_os_thread.h>
+#include <VP_Os/vp_os_signal.h>
+
+// ARDroneLib
+#include "ARDroneTypes.h"
+#include <control_states.h>
+#include <ardrone_tool/Navdata/ardrone_navdata_file.h>
+#include <ardrone_tool/Navdata/ardrone_navdata_client.h>
+#include <ardrone_tool/UI/ardrone_input.h>
+
+#include "common.h"
+#include "nav_data.h"
+
+static const char* TAG = "NAV_DATA";
+navdata_unpacked_t inst_nav;
+vp_os_mutex_t instance_navdata_mutex;
+
+static bool_t bIsInitialized = FALSE;
+
+
+inline C_RESULT navdata_init( void* data )
+{
+	LOGD(TAG, "navdata_init");
+	vp_os_mutex_init(&instance_navdata_mutex);
+	vp_os_mutex_lock( &instance_navdata_mutex);
+	navdata_reset(&inst_nav);
+	bIsInitialized = TRUE;
+	vp_os_mutex_unlock( &instance_navdata_mutex);
+	return C_OK;
+}
+
+
+inline C_RESULT navdata_process( const navdata_unpacked_t* const navdata )
+{
+	if (bIsInitialized == FALSE) {
+		LOGW(TAG, "Navdata is not initialized yet");
+		return C_OK;
+	}
+
+	vp_os_mutex_lock( &instance_navdata_mutex);
+	vp_os_memcpy(&inst_nav, navdata, sizeof(navdata_unpacked_t));
+	vp_os_mutex_unlock( &instance_navdata_mutex );
+
+	return C_OK;
+}
+
+
+inline C_RESULT navdata_release( void )
+{
+	LOGI(TAG, "navdata_release");
+	vp_os_mutex_destroy(&instance_navdata_mutex);
+	bIsInitialized = FALSE;
+    return C_OK;
+}
+
+
+C_RESULT navdata_reset(navdata_unpacked_t *nav)
+{
+	C_RESULT result = C_FAIL;
+
+	if(nav)
+	{
+		vp_os_memset(nav, 0x0, sizeof(navdata_unpacked_t));
+        nav->ardrone_state |= ARDRONE_NAVDATA_BOOTSTRAP;
+        result = C_OK;
+	}
+
+	return result;
+}
+
+
+C_RESULT navdata_get(navdata_unpacked_t *data)
+{
+	C_RESULT result = C_FAIL;
+
+	if(data)
+	{
+		vp_os_mutex_lock( &instance_navdata_mutex );
+		vp_os_memcpy(data, &inst_nav, sizeof(navdata_unpacked_t));
+		vp_os_mutex_unlock( &instance_navdata_mutex );
+		result = C_OK;
+	}
+
+	return result;
+}
+
+
+
+BEGIN_NAVDATA_HANDLER_TABLE
+	NAVDATA_HANDLER_TABLE_ENTRY(navdata_init, navdata_process, navdata_release, NULL)
+END_NAVDATA_HANDLER_TABLE

app/src/main/jni/API/NavData/nav_data.h

+/*
+ * nav_data.h
+ *
+ *  Created on: May 13, 2011
+ *      Author: "Dmytro Baryskyy"
+ */
+
+#ifndef NAV_DATA_H_
+#define NAV_DATA_H_
+
+//typedef struct _instance_navdata_t {
+//	uint32_t battery_level;
+//	uint32_t altitude;
+//	uint32_t prev_control_state;
+//	uint32_t current_control_state;
+//	uint32_t ardrone_state;
+//	uint32_t alert_state;
+//	uint32_t emergency_state;
+//	uint32_t num_frames;
+//	bool_t wifiReachable;
+//	bool_t   flying;
+//} instance_navdata_t;
+//extern instance_navdata_t instance_navdata;
+
+C_RESULT navdata_reset(navdata_unpacked_t *nav);
+C_RESULT navdata_get(navdata_unpacked_t *data);
+C_RESULT navdata_write_to_file(bool_t enable);
+
+//extern C_RESULT parrot_ardrone_navdata_get(instance_navdata_t */*data*/);
+//extern inline void parrot_ardrone_navdata_checkErrors();
+
+#endif /* NAV_DATA_H_ */

app/src/main/jni/API/Plf/plf.c

+/*
+ *  plf.c
+ *  ARUpdater
+ *
+ *  Created by f.dhaeyer on 06/07/10.
+ *  Copyright 2010 Parrot SA. All rights reserved.
+ *
+ */
+#include <stdio.h>
+#include <string.h>
+#include "plf.h"
+
+/** Get version numbers of plf
+ * @return -1 if error of file, else 0 
+ */
+int
+plf_get_header(const char *plf_filename, plf_phdr *header) 
+{
+	plf_phdr h;
+	int result = -1;
+	FILE *f = fopen(plf_filename, "rb");
+	if(f != NULL)
+	{
+		printf("File %s opened\n", plf_filename);
+		if(fread(&h, 1, sizeof(plf_phdr), f) == sizeof(plf_phdr))
+		{
+			memcpy(header, &h, sizeof(plf_phdr));
+			result = 0;
+		}
+		fclose(f);
+	}
+	
+	return result;
+}

app/src/main/jni/API/Plf/plf.h

+/*
+ *  plf.h
+ *  ARUpdater
+ *
+ *  Created by f.dhaeyer on 06/07/10.
+ *  Copyright 2010 Parrot SA. All rights reserved.
+ *
+ */
+
+#ifndef _PLF_H_
+#define _PLF_H_
+
+#define PLF_CURRENT_VERSION  10
+#define PLF_HEADER_MAGIC     0x21464c50 //!< PLF magic number
+
+typedef unsigned int   Plf_Word;        //!< Unsigned 32 bits integer
+typedef unsigned short Plf_Half;        //!< Unsigned 16 bits integer
+typedef void*          Plf_Add;         //!< 32 bits address
+
+//! PLF file header
+typedef struct {
+	Plf_Word    p_magic;                  //!< PLF magic number
+	Plf_Word    p_plfversion;             //!< PLF format version
+	Plf_Word    p_phdrsize;               //!< File header size
+	Plf_Word    p_shdrsize;               //!< Section header size
+	Plf_Word    p_type;                   //!< File type
+	Plf_Add     p_entry;                  //!< Executable entry point
+	Plf_Word    p_targ;                   //!< Target platform
+	Plf_Word    p_app;                    //!< Target application
+	Plf_Word    p_hdw;                    //!< Hardware compatibility
+	Plf_Word    p_ver;                    //!< Version
+	Plf_Word    p_edit;                   //!< Edition
+	Plf_Word    p_ext;                    //!< Extension
+	Plf_Word    p_lang;                   //!< Language zone
+	Plf_Word    p_size;                   //!< File size in bytes
+} plf_phdr;
+
+int plf_get_header(const char *plf_filename, plf_phdr *header);
+#endif // _PLF_H_

app/src/main/jni/API/Stubs/drone_config_stub.c

+/*
+ * drone_confg_stub.c
+ *
+ *  Created on: Jun 10, 2011
+ *      Author: Dmytro Baryskyy
+ */
+
+
+#include "common.h"
+#include "drone_config_stub.h"
+
+static jobject configObj = NULL;
+
+static const char* TAG = "DRONE_CONFIG_STUB";
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateOutdoorHullNative(JNIEnv *env, jobject obj)
+{
+	jclass configCls = (*env)->GetObjectClass(env, obj);
+
+	// Outdoor hull
+	jfieldID outdoorHullFid = (*env)->GetFieldID(env, configCls, "outdoorHull",  "Z");
+	jboolean bOutdoorHull = (*env)->GetBooleanField(env, obj, outdoorHullFid);
+
+	ardrone_control_config.flight_without_shell = bOutdoorHull;
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(flight_without_shell, &ardrone_control_config.flight_without_shell, NULL);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, configCls);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateAdaptiveVideoNative(JNIEnv *env, jobject obj)
+{
+	jclass configCls = (*env)->GetObjectClass(env, obj);
+
+	// Adaptive video
+	jfieldID adaptiveVideoFid = (*env)->GetFieldID(env, configCls, "adaptiveVideo",  "Z");
+	jboolean bAdaptiveVideo = (*env)->GetBooleanField(env, obj, adaptiveVideoFid);
+
+	if (IS_ARDRONE1) {
+		ARDRONE_VARIABLE_BITRATE enabled = (bAdaptiveVideo == TRUE) ? ARDRONE_VARIABLE_BITRATE_MODE_DYNAMIC : ARDRONE_VARIABLE_BITRATE_MANUAL;
+		uint32_t constantBitrate = (UVLC_CODEC == ardrone_control_config.video_codec) ? 20000 : 15000;
+		ardrone_control_config.bitrate_ctrl_mode = enabled;
+		ardrone_control_config.bitrate = constantBitrate;
+
+		ARDRONE_TOOL_CONFIGURATION_ADDEVENT(bitrate_ctrl_mode, &ardrone_control_config.bitrate_ctrl_mode, NULL);
+		ARDRONE_TOOL_CONFIGURATION_ADDEVENT(bitrate, &ardrone_control_config.bitrate, NULL);
+	} else if (IS_ARDRONE2) {
+        ARDRONE_VARIABLE_BITRATE enabled = (bAdaptiveVideo) ? ARDRONE_VARIABLE_BITRATE_MODE_DYNAMIC : ARDRONE_VARIABLE_BITRATE_MODE_DISABLED;
+        ardrone_control_config.bitrate_ctrl_mode = enabled;
+        ARDRONE_TOOL_CONFIGURATION_ADDEVENT(bitrate_ctrl_mode, &ardrone_control_config.bitrate_ctrl_mode, NULL);
+	}
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, configCls);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateOwnerMacNative(JNIEnv *env, jobject obj)
+{
+	jclass configCls = (*env)->GetObjectClass(env, obj);
+
+	// Owner Mac
+	jfieldID pairingFid  = (*env)->GetFieldID(env, configCls, "ownerMac",  "Ljava/lang/String;");
+	jstring strOwnerMac = (*env)->GetObjectField(env, obj, pairingFid);
+
+	const jbyte *owner_mac_arr;
+	owner_mac_arr = (*env)->GetStringUTFChars(env, strOwnerMac, NULL);
+
+	if (owner_mac_arr == NULL) {
+		return; /* OutOfMemoryError already thrown */
+	}
+
+	strcpy(ardrone_control_config.owner_mac, owner_mac_arr);
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(owner_mac, ardrone_control_config.owner_mac, NULL);
+	(*env)->ReleaseStringUTFChars(env, strOwnerMac, owner_mac_arr);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, configCls);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateAltitudeLimit(JNIEnv *env, jobject obj, jint altitude)
+{
+	ardrone_control_config.altitude_max = altitude * 1000;
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(altitude_max, &ardrone_control_config.altitude_max, NULL);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateOutdoorFlightNative(JNIEnv *env, jobject obj)
+{
+	jclass configCls = (*env)->GetObjectClass(env, obj);
+
+	jfieldID outdoorFlightFid = (*env)->GetFieldID(env, configCls, "outdoorFlight",  "Z");
+	ardrone_control_config.outdoor = (*env)->GetBooleanField(env, obj, outdoorFlightFid);;
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(outdoor, &ardrone_control_config.outdoor, NULL);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, configCls);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateYawSpeedMaxNative(JNIEnv *env, jobject obj)
+{
+	jclass configCls = (*env)->GetObjectClass(env, obj);
+
+	// Yaw Speed Max
+	jfieldID yawSpeedMaxFid = (*env)->GetFieldID(env, configCls, "yawSpeedMax",  "I");
+	jint yawSpeedMax = (*env)->GetIntField(env, obj, yawSpeedMaxFid);
+	ardrone_control_config.control_yaw = (float)yawSpeedMax * DEG_TO_RAD;
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(control_yaw, &ardrone_control_config.control_yaw, NULL);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, configCls);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateVertSpeedMaxNative(JNIEnv *env, jobject obj)
+{
+	jclass configCls = (*env)->GetObjectClass(env, obj);
+
+	// Vertical Speed Max
+	jfieldID vertSpeedMaxFid = (*env)->GetFieldID(env, configCls, "vertSpeedMax",  "I");
+	jint vertSpeedMax = (*env)->GetIntField(env, obj,vertSpeedMaxFid);
+	ardrone_control_config.control_vz_max = vertSpeedMax;
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(control_vz_max, &ardrone_control_config.control_vz_max, NULL);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, configCls);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateTiltNative(JNIEnv *env, jobject obj)
+{
+	jclass configCls = (*env)->GetObjectClass(env, obj);
+
+	// Tilt
+	jfieldID tiltFid = (*env)->GetFieldID(env, configCls, "tilt",  "I");
+	jint tiltMax = (*env)->GetIntField(env, obj, tiltFid);
+	ardrone_control_config.euler_angle_max = (float)tiltMax * DEG_TO_RAD;
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(euler_angle_max, &ardrone_control_config.euler_angle_max, NULL);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, configCls);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateDeviceTiltMax(JNIEnv *env, jobject obj, jint tilt)
+{
+	ardrone_control_config.control_iphone_tilt = (float)tilt * DEG_TO_RAD;
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(control_iphone_tilt, &ardrone_control_config.control_iphone_tilt, NULL);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateNetworkNameNative(JNIEnv *env, jobject obj)
+{
+	jclass configCls = (*env)->GetObjectClass(env, obj);
+
+	// Network name
+	jfieldID networkNameFid = (*env)->GetFieldID(env, configCls, "networkName",  "Ljava/lang/String;");
+	jstring strNetworkName = (*env)->GetObjectField(env, obj, networkNameFid);
+	const jbyte *network_name_str = (*env)->GetStringUTFChars(env, strNetworkName, NULL);
+
+	if (network_name_str == NULL) {
+		return; /* OutOfMemoryError already thrown */
+	}
+
+	strcpy(ardrone_control_config.ssid_single_player,network_name_str);
+	ARDRONE_TOOL_CONFIGURATION_ADDEVENT(ssid_single_player, &ardrone_control_config.ssid_single_player, NULL);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, configCls);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateVideoCodecNative(JNIEnv *env, jobject obj)
+{
+	jclass configCls = (*env)->GetObjectClass(env, obj);
+
+	// Video codec
+	jfieldID videoCodecFid  = (*env)->GetFieldID(env, configCls, "videoCodec",  "I");
+	jint videoCodec = (*env)->GetIntField(env, obj, videoCodecFid);
+
+	if (IS_ARDRONE1) {
+		if (videoCodec == P264_CODEC || videoCodec == UVLC_CODEC) {
+			LOGI(TAG, "Setting %s codec", (videoCodec == P264_CODEC?"P264":"UVLC"));
+			ardrone_control_config.video_codec = videoCodec;
+			ARDRONE_TOOL_CONFIGURATION_ADDEVENT(video_codec, &ardrone_control_config.video_codec, NULL);
+			ardrone_control_config.bitrate = (UVLC_CODEC == ardrone_control_config.video_codec) ? 20000 : 15000;
+			ARDRONE_TOOL_CONFIGURATION_ADDEVENT(bitrate, &ardrone_control_config.bitrate, NULL);
+		} else {
+			LOGW(TAG, "Can't set codec. Unknown codec %d", videoCodec);
+		}
+	} else if (IS_ARDRONE2) {
+		if (videoCodec > UVLC_CODEC && videoCodec <= H264_AUTO_RESIZE_CODEC) {
+			ardrone_control_config.video_codec = videoCodec;
+			ARDRONE_TOOL_CONFIGURATION_ADDEVENT(video_codec, &ardrone_control_config.video_codec, NULL);
+		} else {
+			LOGW(TAG, "Can't set codec. Unknown codec %d", videoCodec);
+		}
+	}
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, configCls);
+}
+
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_updateRecordOnUsb(JNIEnv *env, jobject obj)
+{
+	if (IS_ARDRONE2) {
+        ardrone_control_config.video_on_usb = java_get_bool_field_value(env, obj, "recordOnUsb");
+        ARDRONE_TOOL_CONFIGURATION_ADDEVENT(video_on_usb, &ardrone_control_config.video_on_usb, NULL);
+        LOGD(TAG, "Settings Video on USB to %d", ardrone_control_config.video_on_usb);
+	} else {
+		LOGW(TAG, "Can't set video on usb value for AR.Drone 1");
+	}
+}
+
+
+JNIEXPORT jint JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_getDroneFamily(JNIEnv *env, jobject obj)
+{
+	return ARDRONE_VERSION();
+}
+
+
+JNIEXPORT int JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_getFtpPortNative(JNIEnv *env, jclass class)
+{
+	return FTP_PORT;
+}
+
+
+JNIEXPORT jstring JNICALL
+Java_com_parrot_freeflight_drone_DroneConfig_getDroneHostNative(JNIEnv *env, jclass class)
+{
+	jstring host = (*env)->NewStringUTF(env, WIFI_ARDRONE_IP);
+	return host;
+}

app/src/main/jni/API/Stubs/drone_config_stub.h

+/*
+ * drone_config_stub.h
+ *
+ *  Created on: Jun 10, 2011
+ *      Author: "Dmytro Baryskyy"
+ */
+
+#ifndef DRONE_CONFIG_STUB_H_
+#define DRONE_CONFIG_STUB_H_
+
+extern const int ALTITUDE_LIMITED;
+extern const int NO_ALTITUDE;
+
+#endif /* DRONE_CONFIG_STUB_H_ */

app/src/main/jni/API/Stubs/ftp_client_stub.c

+/*
+ * ftp_client_stub.c
+ *
+ *  Created on: Jul 26, 2011
+ *      Author: "Dmytro Baryskyy"
+ */
+
+#include "common.h"
+#include <utils/ardrone_ftp.h>
+
+static char* TAG = "ftp_client_stub";
+
+static _ftp_status get_ftp_status(JNIEnv *env, jobject obj)
+{
+	jclass ftpClientClass = (*env)->GetObjectClass(env, obj);
+
+	jfieldID ftpStatusFid  = (*env)->GetFieldID(env, ftpClientClass, "ftpStatus",  "I");
+	jlong ftpStatus = (*env)->GetIntField(env, obj, ftpStatusFid);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, ftpClientClass);
+
+	return (_ftp_status) ftpStatus;
+}
+
+
+static _ftp_t* get_ftp_handle(JNIEnv *env, jobject obj)
+{
+	jclass ftpClientClass = (*env)->GetObjectClass(env, obj);
+
+	jfieldID connectionHandleFid  = (*env)->GetFieldID(env, ftpClientClass, "connectionHandle",  "I");
+	jint connectionHandle = (*env)->GetIntField(env, obj, connectionHandleFid);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, ftpClientClass);
+
+	_ftp_t* ftp_handle = (_ftp_t*) connectionHandle;
+
+	if (ftp_handle != NULL)
+	{
+		if (ftp_handle->tag != NULL)
+		{
+			// Deleting old reference to java ftpclient object
+			jobject caller = ftp_handle->tag;
+			(*env)->DeleteGlobalRef(env, caller);
+			ftp_handle->tag = NULL;
+		}
+
+		// we need to save the object that is calling this method in order to call callback of this object
+		ftp_handle->tag = (*env)->NewGlobalRef(env, obj);
+	}
+
+	return ftp_handle;
+}
+
+
+static void update_ftp_status_field(JNIEnv *env, jobject obj, _ftp_status status)
+{
+	jclass ftpClientClass = (*env)->GetObjectClass(env, obj);
+
+	jfieldID ftpStatusFid  = (*env)->GetFieldID(env, ftpClientClass, "ftpStatus",  "I");
+	(*env)->SetIntField(env, obj, ftpStatusFid, (jint)status);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, ftpClientClass);
+}
+
+
+static void update_conn_handler_field(JNIEnv *env, jobject obj, _ftp_t* handle)
+{
+	jclass ftpClientClass = (*env)->GetObjectClass(env, obj);
+
+	jfieldID connectionHandleFid  = (*env)->GetFieldID(env, ftpClientClass, "connectionHandle",  "I");
+	(*env)->SetIntField(env, obj, connectionHandleFid, (jint)handle);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, ftpClientClass);
+}
+
+
+static void wrapperCallback (_ftp_status status, void *arg, _ftp_t *ftp)
+{
+	JNIEnv* jniEnv = NULL;
+	jobject obj = ftp->tag;
+
+	if (obj == NULL) {
+		LOGW(TAG, "wrapperCallback(). Can't call callback. Env or object is null");
+		return;
+	}
+
+	if (g_vm)
+	{
+		(*g_vm)->AttachCurrentThread (g_vm, (JNIEnv **) &jniEnv, NULL);
+	}
+	else
+	{
+		LOGW(TAG, "g_vm is not available!");
+	}
+
+	jclass cls = (*jniEnv)->GetObjectClass(jniEnv, obj);
+	jmethodID mid = (*jniEnv)->GetMethodID(jniEnv, cls, "callback", "(IFLjava/lang/String;)V");
+
+	  if (mid == 0) {
+		  LOGE(TAG, "Can't find method callback");
+		  return;
+	  }
+
+	jint locStatus = (jint)status;
+	jfloat progress = 0.0f;
+	jstring fileList = NULL;
+	jint operation = 0;
+
+
+	if (FTP_PROGRESS == locStatus && NULL != arg)
+	{
+		progress = *(jfloat *)arg;
+		fileList = NULL;
+	}
+
+	(*jniEnv)->CallVoidMethod(jniEnv, obj, mid, locStatus, progress, fileList);
+
+	// Removing reference to the class instance
+	(*jniEnv)->DeleteLocalRef(jniEnv, cls);
+
+	if (g_vm)
+	{
+		(*g_vm)->DetachCurrentThread (g_vm);
+	}
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_ftp_FTPClient_ftpConnect(JNIEnv *env, jobject obj, jstring ip, jint port, jstring username, jstring password)
+{
+	 _ftp_status initResult = FTP_FAIL;
+
+	 const char *ipAddressASCII = (*env)->GetStringUTFChars(env, ip, NULL);
+	 const char *usernameASCII = (*env)->GetStringUTFChars(env, username, NULL);
+	 const char *passwordASCII = (*env)->GetStringUTFChars(env, password, NULL);
+
+	 if (ipAddressASCII == NULL || usernameASCII == NULL) {
+		 return FALSE; /* OutOfMemoryError already thrown */
+	 }
+
+	 _ftp_t* ftp = ftpConnect (ipAddressASCII,
+	                           port,
+	                           usernameASCII,
+	                           passwordASCII,
+	                           &initResult);
+
+ 	(*env)->ReleaseStringUTFChars(env, ip, ipAddressASCII);
+ 	(*env)->ReleaseStringUTFChars(env, username, usernameASCII);
+	(*env)->ReleaseStringUTFChars(env, password, passwordASCII);
+
+	update_ftp_status_field(env, obj, initResult);
+	update_conn_handler_field(env, obj, ftp);
+
+	return FTP_SUCCEDED(initResult)?TRUE:FALSE;
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_ftp_FTPClient_ftpDisconnect(JNIEnv *env, jobject obj)
+{
+	_ftp_t* ftp = get_ftp_handle(env, obj);
+
+	if (ftp == NULL) {
+		LOGW(TAG, "ftpDisconnect: Connection is null");
+		return FALSE;
+	}
+
+	if (ftp->tag != NULL) {
+		jobject tag = ftp->tag;
+		(*env)->DeleteGlobalRef(env, tag);
+		ftp->tag = NULL;
+	}
+
+	_ftp_status status = ftpClose(&ftp);
+
+	update_ftp_status_field(env, obj, status);
+	update_conn_handler_field(env, obj, ftp);
+
+
+	return FTP_SUCCEDED(status)?TRUE:FALSE;
+}
+
+
+static jboolean
+ftp_ftpGet(JNIEnv *env, jobject obj, ftp_callback callback, jstring remoteName, jstring localName, jboolean useResume)
+{
+	if (localName == NULL || remoteName == NULL) {
+			LOGW(TAG, "ftpGet() failed. Invalid parameters.");
+			return FALSE;
+		}
+
+		const char *localNameASCII = (*env)->GetStringUTFChars(env, localName, NULL);
+		_ftp_t* ftp = get_ftp_handle(env, obj);
+		const char *remoteNameASCII = (*env)->GetStringUTFChars(env, remoteName, NULL);
+
+		if (ftp == NULL) {
+			LOGW(TAG, "ftpGet: Connection is null");
+			return FALSE;
+		}
+
+		_ftp_status status = ftpGet(ftp, remoteNameASCII, localNameASCII, useResume == TRUE ? 1 : 0, callback);
+
+		update_ftp_status_field(env, obj, status);
+		update_conn_handler_field(env, obj, ftp);
+
+		return (FTP_SUCCEDED(status)?TRUE:FALSE);
+}
+
+
+static jboolean
+ftp_ftpPut(JNIEnv *env, jobject obj, ftp_callback callback, jstring localName, jstring remoteName, jboolean useResume)
+{
+	if (localName == NULL || remoteName == NULL) {
+		LOGW(TAG, "ftpPut() failed. Invalid parameters.");
+		return FALSE;
+	}
+
+	_ftp_t* ftp = get_ftp_handle(env, obj);
+
+	if (ftp == NULL) {
+		LOGW(TAG, "ftpPut: Connection is null");
+		return FALSE;
+	}
+
+	 const char *localNameASCII = (*env)->GetStringUTFChars(env, localName, NULL);
+	 const char *remoteNameASCII = (*env)->GetStringUTFChars(env, remoteName, NULL);
+
+	_ftp_status status = ftpPut(ftp, localNameASCII, remoteNameASCII, useResume==TRUE?1:0, callback);
+
+ 	(*env)->ReleaseStringUTFChars(env, localName, localNameASCII);
+ 	(*env)->ReleaseStringUTFChars(env, remoteName, remoteNameASCII);
+
+ 	update_ftp_status_field(env, obj, status);
+ 	update_conn_handler_field(env, obj, ftp);
+
+ 	return (FTP_SUCCEDED(status)?TRUE:FALSE);
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_ftp_FTPClient_ftpIsConnected(JNIEnv *env, jobject obj)
+{
+	_ftp_t* ftp = get_ftp_handle(env, obj);
+
+	if (ftp != NULL) {
+		return (ftp->connected>0?TRUE:FALSE);
+	}
+
+	return FALSE;
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_ftp_FTPClient_ftpAbort(JNIEnv *env, jobject obj)
+{
+	_ftp_t* ftp = get_ftp_handle(env, obj);
+
+	if (ftp == NULL) {
+		LOGW(TAG, "ftpAbort: Connection is null");
+		return FALSE;
+	}
+
+	if (ftp->tag != NULL) {
+		jobject tag = ftp->tag;
+		(*env)->DeleteGlobalRef(env, tag);
+		ftp->tag = NULL;
+	}
+
+	_ftp_status status = ftpAbort(ftp);
+
+	update_ftp_status_field(env, obj, status);
+	update_conn_handler_field(env, obj, ftp);
+
+	return (FTP_SUCCEDED(status)?TRUE:FALSE);
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_ftp_FTPClient_ftpPut(JNIEnv *env, jobject obj, jstring localName, jstring remoteName, jboolean useResume)
+{
+	return ftp_ftpPut(env, obj, wrapperCallback, localName, remoteName, useResume);
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_ftp_FTPClient_ftpPutSync(JNIEnv *env, jobject obj, jstring localName, jstring remoteName, jboolean useResume)
+{
+	return ftp_ftpPut(env, obj, NULL, localName, remoteName, useResume);
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_ftp_FTPClient_ftpGet(JNIEnv *env, jobject obj, jstring remoteName, jstring localName, jboolean useResume)
+{
+	return ftp_ftpGet(env, obj, wrapperCallback, remoteName, localName, useResume);
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_ftp_FTPClient_ftpGetSync(JNIEnv *env, jobject obj, jstring remoteName, jstring localName, jboolean useResume)
+{
+	return ftp_ftpGet(env, obj, NULL, remoteName, localName, useResume);
+}
+

app/src/main/jni/API/Stubs/gl_bg_video_sprite_stub.c

+/*
+ * gl_bg_video_sprite_stub.c
+ *
+ *  Created on: Feb 1, 2012
+ *      Author: "Dmytro Baryskyy"
+ */
+#include "common.h"
+#include <android/bitmap.h>
+
+#include "gl_bg_video_sprite_stub.h"
+#include "../Callbacks/java_callbacks.h"
+
+static char* TAG = "gl_bg_video_sprite";
+
+static opengl_size_t screen_size;
+static bool_t recalculate_video_texture = FALSE;
+static int32_t current_num_picture_decoded = 0;
+static int32_t current_num_frames = 0;
+
+opengl_scaling	 scaling;
+static opengl_texture_t texture;
+static bool_t texture_initialized = FALSE;
+
+static void init_texture()
+{
+	vp_os_memset(&texture, 0, sizeof(opengl_texture_t));
+}
+
+static void recalculate_video_texture_bounds(JNIEnv *env, jobject obj, opengl_texture_t* texture)
+{
+	java_set_field_int(env, obj, "imageWidth", texture->image_size.width);
+	java_set_field_int(env, obj, "imageHeight",  texture->image_size.height);
+	java_set_field_int(env, obj, "textureWidth", texture->texture_size.width);
+	java_set_field_int(env, obj, "textureHeight", texture->texture_size.height);
+}
+
+
+void opengl_texture_scale_compute(opengl_texture_t *texture, opengl_size_t screen_size, opengl_scaling scaling)
+{
+	LOGD(TAG, "%s sizes %f, %f, %f, %f\n", __FUNCTION__, texture->image_size.width, texture->image_size.height, texture->texture_size.width, texture->texture_size.height);
+	switch(scaling)
+	{
+		case NO_SCALING:
+			texture->scaleModelX = texture->image_size.height / screen_size.width;
+			texture->scaleModelY = texture->image_size.width / screen_size.height;
+			break;
+		case FIT_X:
+			texture->scaleModelX = (screen_size.height * texture->image_size.height) / (screen_size.width * texture->image_size.width);
+			texture->scaleModelY = 1.0f;
+			break;
+		case FIT_Y:
+			texture->scaleModelX = 1.0f;
+			texture->scaleModelY = (screen_size.width * texture->image_size.width) / (screen_size.height * texture->image_size.height);
+			break;
+		default:
+			texture->scaleModelX = 1.0f;
+			texture->scaleModelY = 1.0f;
+			break;
+	}
+
+	texture->scaleTextureX = texture->image_size.width / (float)texture->texture_size.width;
+	texture->scaleTextureY = texture->image_size.height / (float)texture->texture_size.height;
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_freeflight_ui_gl_GLBGVideoSprite_onUpdateVideoTextureNative(JNIEnv *env, jobject obj, jint program, jint textureId)
+{
+	if (texture_initialized == FALSE) {
+		init_texture();
+		texture_initialized = TRUE;
+	}
+
+	opengl_video_stage_config_t *config = opengl_video_stage_get();
+
+	if ((config != NULL) && (config->data != NULL) && (config->num_picture_decoded > current_num_picture_decoded))
+	{
+		if (texture.image_size.width != config->widthImage) {
+			recalculate_video_texture = TRUE;
+		}
+
+		texture.bytesPerPixel       = config->bytesPerPixel;
+		texture.image_size.width    = config->widthImage;
+		texture.image_size.height   = config->heightImage;
+		texture.texture_size.width	= config->widthTexture;
+		texture.texture_size.height	= config->heightTexture;
+		texture.format              = config->format;
+		texture.type                = config->type;
+		texture.data                = config->data;
+		texture.state = OPENGL_STATE_GENERATED;
+
+        current_num_picture_decoded = config->num_picture_decoded;
+		current_num_frames = config->num_frames;
+	}
+
+	if (recalculate_video_texture) {
+		recalculate_video_texture_bounds(env, obj, &texture);
+		recalculate_video_texture = FALSE;
+	}
+
+	if(texture.state == OPENGL_STATE_GENERATED)
+	{
+		// Load the texture in the GPU
+		if (texture.data != NULL) {
+//			LOGD("GL_BG_VIDEO_SPRITE", "fmt: %d, w: %f, h: %f, type: %d, data: %p", texture.format, texture.texture_size.width, texture.texture_size.height, texture.type, texture.data);
+			glTexImage2D(GL_TEXTURE_2D, 0, texture.format, texture.texture_size.width, texture.texture_size.height, 0, texture.format, texture.type, texture.data);
+			texture.state = OPENGL_STATE_SEND_TO_GPU;
+
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+JNIEXPORT void JNICALL
+Java_com_parrot_freeflight_ui_gl_GLBGVideoSprite_onSurfaceChangedNative(JNIEnv *env, jobject obj, jint width, jint height)
+{
+	screen_size.width = width;
+	screen_size.height = height;
+
+	recalculate_video_texture = TRUE;
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_freeflight_ui_gl_GLBGVideoSprite_getVideoFrameNative(JNIEnv *env, jobject obj, jobject bitmap, jfloatArray videoSize)
+{
+	AndroidBitmapInfo  info;
+	void*              pixels;
+	int                ret;
+	jboolean result = FALSE;
+
+	if (screen_size.width == 0 || screen_size.height == 0)
+		return FALSE;
+
+	if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {
+		return FALSE;
+	}
+
+	if (info.format != ANDROID_BITMAP_FORMAT_RGB_565) {
+		return FALSE;
+	}
+
+	opengl_video_stage_config_t *config = opengl_video_stage_get();
+
+	if ((config != NULL) && (config->data != NULL) && (config->num_picture_decoded > current_num_picture_decoded))
+	{
+		if (texture.image_size.width != config->widthImage) {
+			recalculate_video_texture = TRUE;
+		}
+
+		texture.bytesPerPixel       = config->bytesPerPixel;
+		texture.image_size.width    = config->widthImage;
+		texture.image_size.height   = config->heightImage;
+		texture.texture_size.width	= config->widthTexture;
+		texture.texture_size.height	= config->heightTexture;
+		texture.format              = config->format;
+		texture.type                = config->type;
+		texture.data                = config->data;
+		texture.state = OPENGL_STATE_GENERATED;
+
+        current_num_picture_decoded = config->num_picture_decoded;
+		current_num_frames = config->num_frames;
+	}
+
+	if (recalculate_video_texture && screen_size.width != 0 && screen_size.height != 0) {
+		opengl_texture_scale_compute(&texture, screen_size, FIT_X);
+		LOGD("VIDEO", "Screen Widht: %f", screen_size.width);
+		recalculate_video_texture = FALSE;
+	}
+
+	if (texture.state == OPENGL_STATE_GENERATED)
+	{
+		if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
+		}
+
+		result = TRUE;
+
+		memcpy(pixels, texture.data, texture.image_size.width * texture.image_size.height  * texture.bytesPerPixel);
+
+		texture.state = OPENGL_STATE_SEND_TO_GPU;
+
+		jfloat *body = (*env)->GetFloatArrayElements(env, videoSize, 0);
+		body[0] = (float)texture.image_size.width;
+		body[1] = (float)texture.image_size.height;
+		body[2] = (float)texture.scaleModelX;
+		body[3] = (float)texture.scaleModelY;
+
+		(*env)->ReleaseFloatArrayElements(env, videoSize, body, 0);
+
+		AndroidBitmap_unlockPixels(env, bitmap);
+
+	}
+
+	return result;
+}
+
+

app/src/main/jni/API/Stubs/gl_bg_video_sprite_stub.h

+/*
+ * gl_bg_video_sprite_stub.h
+ *
+ *  Created on: Jul 27, 2012
+ *      Author: "Dmytro Baryskyy"
+ */
+
+#ifndef GL_BG_VIDEO_SPRITE_STUB_H_
+#define GL_BG_VIDEO_SPRITE_STUB_H_
+
+typedef enum
+{
+	NO_SCALING,
+	FIT_X,
+	FIT_Y,
+	FIT_XY
+} opengl_scaling;
+
+
+typedef enum
+{
+    OPENGL_STATE_INITIALIZED = 0,
+    OPENGL_STATE_GENERATED,
+    OPENGL_STATE_SEND_TO_GPU
+} opengl_state;
+
+
+typedef struct
+{
+    GLfloat width;
+    GLfloat height;
+} opengl_size_t;
+
+
+typedef struct
+{
+	opengl_size_t image_size;
+	opengl_size_t texture_size;
+	GLfloat scaleModelX;
+	GLfloat scaleModelY;
+	GLfloat scaleTextureX;
+	GLfloat scaleTextureY;
+	GLuint bytesPerPixel;
+	GLenum format;
+	GLenum type;
+	void* data;
+	GLuint textureId[2];
+	GLuint vertexBufferId;
+	GLuint indexBufferId;
+
+	opengl_state state;
+} opengl_texture_t;
+
+
+#endif /* GL_BG_VIDEO_SPRITE_STUB_H_ */

app/src/main/jni/API/Stubs/plf_file_stub.c

+/*
+ * plf_file_stub.c
+ *
+ *  Created on: Aug 30, 2011
+ *      Author: Dmytro Baryskyy
+ */
+
+#include "common.h"
+#include "../Plf/plf.h"
+
+
+static char* TAG = {"PLF_FILE_STUB\0"};
+
+static jbyteArray getHeader(JNIEnv* env, jobject obj, jint size)
+{
+	jclass cls = (*env)->GetObjectClass(env, obj);
+	jmethodID mid = (*env)->GetMethodID(env, cls, "getHeader", "(I)[B");
+
+	if (mid == 0) {
+		LOGW(TAG, "Method not found");
+		return NULL;
+	}
+
+	// Getting the file header from java code
+	jbyteArray result = (*env)->CallObjectMethod(env, obj, mid, size);
+
+	// Removing reference to the class instance
+	(*env)->DeleteLocalRef(env, cls);
+
+	return result;
+}
+
+
+JNIEXPORT jstring JNICALL
+Java_com_parrot_plf_PlfFile_getVersionNative(JNIEnv *env, jobject obj)
+{
+	jbyteArray headerDataArray = getHeader(env, obj, sizeof(plf_phdr));
+
+	if (headerDataArray == NULL) {
+		LOGE(TAG, "Can't get plf header");
+		return NULL;
+	}
+
+	jbyte* const rawHeader = (*env)->GetByteArrayElements( env, headerDataArray , 0);
+
+	plf_phdr plf_header;
+	memcpy(&plf_header, rawHeader, sizeof(plf_phdr));
+
+	(*env)->ReleaseByteArrayElements(env, headerDataArray, rawHeader, JNI_ABORT);
+
+	char version[256] = {0};
+	sprintf(version, "%d.%d.%d", plf_header.p_ver, plf_header.p_edit, plf_header.p_ext);
+
+	LOGI(TAG, "Version of plf file: %s", version);
+
+	return (*env)->NewStringUTF(env, version);
+}

app/src/main/jni/API/Stubs/transcoding_service_stub.h

+/*
+ * transcoding_service_stub.h
+ *
+ *  Created on: Apr 6, 2012
+ *      Author: "Dmytro Baryskyy"
+ */
+
+#ifndef TRANSCODING_SERVICE_STUB_H_
+#define TRANSCODING_SERVICE_STUB_H_
+
+
+typedef enum
+{
+	VIDEO_RECORD_HOLD, // Video recording is on hold, waiting for the start command. This is the default state.
+	VIDEO_RECORD_START, // Video recording has started.
+	VIDEO_PICTURE_START,
+	VIDEO_PICTURE_HOLD,
+	VIDEO_RECORD_STOP		// Video recording has been stopped. Stage will end and restart.
+} video_record_state;
+
+
+typedef struct _encoder_stage_config_t_
+{
+	// Public
+    char *file_src;
+    char *file_dest;
+    video_record_state startRec;
+    vlib_stage_decoding_config_t *vlib_stage_decoding_config;
+
+    AVCodec *codec;
+    AVFormatContext *oc;
+    AVOutputFormat *fmt;
+    AVStream *video_s;
+    AVCodecContext *c;
+    int i, out_size, size, x, y, outbuf_size;
+    FILE *f;
+
+    // Private
+    uint32_t *numframes;
+    int starting_num_frames;
+    int previous_num_picture_decoded;
+    bool_t success;
+    bool_t first_frame_ok;
+    bool_t video_file_open;
+} encoder_stage_config_t;
+
+
+static C_RESULT create_video_file(const char*filename,int width,int height,int frame_rate, enum PixelFormat pix_fmt);
+static void close_video_file();
+static AVStream *add_video_stream(AVFormatContext *oc, enum CodecID codec_id,int width, int height, int frame_rate, enum PixelFormat pix_fmt);
+static AVFrame *alloc_picture(enum PixelFormat pix_fmt, int width, int height);
+static C_RESULT open_video(AVFormatContext *oc, AVStream *st);
+static C_RESULT write_video_frame(AVFormatContext *oc, AVStream *st);
+static void close_video(AVFormatContext *oc, AVStream *st);
+
+
+PROTO_THREAD_ROUTINE(encoder, data);
+
+///////////////////////////////////////////////
+// FUNCTIONS
+
+C_RESULT
+encoder_handle (encoder_stage_config_t * cfg, PIPELINE_MSG msg_id, void *callback, void *param);
+
+/**
+ * @fn      Open the quicktime encoder stage
+ * @param   quicktime_encoder_stage_config_t *cfg
+ * @return  VP_SUCCESS
+ */
+C_RESULT
+encoder_stage_open(encoder_stage_config_t *cfg);
+
+/**
+ * @fn      Transform the quicktime encoder stage
+ * @param   quicktime_encoder_stage_config_t *cfg
+ * @param   vp_api_io_data_t *in
+ * @param   vp_api_io_data_t *out
+ * @return  VP_SUCCESS
+ */
+C_RESULT
+encoder_stage_transform(encoder_stage_config_t *cfg, vp_api_io_data_t *in, vp_api_io_data_t *out);
+
+/**
+ * @fn      Close the quicktime encoder stage
+ * @param   quicktime_encoder_stage_config_t *cfg
+ * @return  VP_SUCCESS
+ */
+C_RESULT
+encoder_stage_close(encoder_stage_config_t *cfg);
+
+
+extern const vp_api_stage_funcs_t encoder_stage_funcs;
+
+
+#endif /* TRANSCODING_SERVICE_STUB_H_ */

app/src/main/jni/API/Video/frame_rate.c

+/*
+ * frame_rate.c
+ *
+ *  Created on: May 20, 2011
+ *      Author: "Dmytro Baryskyy"
+ */
+
+#include <time.h>
+
+#include "common.h"
+#include "frame_rate.h"
+
+
+//FPS will be calculated by measuring time that 30 frames took to render.
+static const int FRAMES_COUNT = 240;
+
+//Used to calculate frames count
+static int renderedFramesCount = 0;
+
+//Used to calculate render time
+static time_t start = 0;
+
+static float fps;
+
+void parrot_frame_rate_init()
+{
+	renderedFramesCount = 0;
+	start = time(NULL);
+}
+
+
+void parrot_frame_rate_on_draw_completed()
+{
+	renderedFramesCount += 1;
+
+	if (renderedFramesCount > FRAMES_COUNT) {
+		fps = (float)renderedFramesCount / ((float)(time(NULL) - start));
+		LOGI("FRAME_RATE", "FPS: %.2f", fps);
+
+		renderedFramesCount = 0;
+		start = time(NULL);
+	}
+}

app/src/main/jni/API/Video/frame_rate.h

+/*
+ * frame_rate.h
+ *
+ *  Created on: May 20, 2011
+ *      Author: "Dmytro Baryskyy"
+ */
+
+#ifndef FRAME_RATE_H_
+#define FRAME_RATE_H_
+
+extern void parrot_frame_rate_init();
+extern void parrot_frame_rate_on_draw_completed();
+
+#endif /* FRAME_RATE_H_ */

app/src/main/jni/API/Video/opengl_shader.c

+//
+//  Shaders.m
+//  FreeFlight
+//
+//  Created by Frédéric D'HAEYER on 24/10/11.
+//  Copyright 2011 PARROT. All rights reserved.
+//
+#include "opengl_shader.h"
+#include "common.h"
+
+/* Create and compile a shader from the provided source(s) */
+GLint opengl_shader_compile(GLuint *shader, GLenum type, GLsizei count, const char* content_file)
+{
+#if defined(DEBUG_SHADER)
+    printf("%s : %d\n", __FUNCTION__, __LINE__);
+#endif
+	GLint status;
+	const GLchar *sources = (const GLchar *)content_file;
+
+	// get source code
+	if (!sources)
+	{
+		printf("Failed to load vertex shader\n");
+		return 0;
+	}
+	
+    *shader = glCreateShader(type);				// create shader
+    glShaderSource(*shader, 1, &sources, NULL);	// set source code in the shader
+    glCompileShader(*shader);					// compile shader
+	
+#if defined(DEBUG_SHADER)
+	GLint logLength;
+    glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0)
+    {
+        GLchar *log = (GLchar *)vp_os_malloc(logLength);
+        glGetShaderInfoLog(*shader, logLength, &logLength, log);
+        printf("Shader compile log:\n%s\n", log);
+        vp_os_free(log);
+    }
+#endif
+    
+    glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);
+    if (status == GL_FALSE)
+	{
+		printf("Failed to compile shader:\n");
+		printf("%s\n", sources);
+	}
+	
+	return status;
+}
+
+
+/* Link a program with all currently attached shaders */
+GLint opengl_shader_link(GLuint prog)
+{
+#if defined(DEBUG_SHADER)
+    printf("%s : %d\n", __FUNCTION__, __LINE__);
+#endif
+	GLint status;
+	
+	glLinkProgram(prog);
+	
+#if defined(DEBUG_SHADER)
+	GLint logLength;
+    glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0)
+    {
+        GLchar *log = (GLchar *)vp_os_malloc(logLength);
+        glGetProgramInfoLog(prog, logLength, &logLength, log);
+        printf("Program link log:\n%s\n", log);
+        vp_os_free(log);
+    }
+#endif
+    
+    glGetProgramiv(prog, GL_LINK_STATUS, &status);
+    if (status == GL_FALSE)
+		printf("Failed to link program %d\n", prog);
+	
+	return status;
+}
+
+
+/* Validate a program (for i.e. inconsistent samplers) */
+GLint opengl_shader_validate(GLuint prog)
+{
+#if defined(DEBUG_SHADER)
+    printf("%s : %d\n", __FUNCTION__, __LINE__);
+#endif
+	GLint logLength, status;
+	
+	glValidateProgram(prog);
+    glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0)
+    {
+        GLchar *log = (GLchar *)vp_os_malloc(logLength);
+        glGetProgramInfoLog(prog, logLength, &logLength, log);
+        printf("Program validate log:\n%s\n", log);
+        vp_os_free(log);
+    }
+    
+    glGetProgramiv(prog, GL_VALIDATE_STATUS, &status);
+    if (status == GL_FALSE)
+		printf("Failed to validate program %d\n", prog);
+	
+	return status;
+}
+
+/* delete shader resources */
+void opengl_shader_destroy(GLuint vertShader, GLuint fragShader, GLuint prog)
+{	
+#if defined(DEBUG_SHADER)
+    printf("%s : %d\n", __FUNCTION__, __LINE__);
+#endif
+	if (vertShader) {
+		glDeleteShader(vertShader);
+		vertShader = 0;
+	}
+	if (fragShader) {
+		glDeleteShader(fragShader);
+		fragShader = 0;
+	}
+	if (prog) {
+		glDeleteProgram(prog);
+		prog = 0;
+	}
+}

app/src/main/jni/API/Video/opengl_shader.h

+//
+//  Shaders.h
+//  FreeFlight
+//
+//  Created by Frédéric D'HAEYER on 24/10/11.
+//  Copyright 2011 PARROT. All rights reserved.
+//
+#ifndef _OPENGL_SHADER_H_
+#define _OPENGL_SHADER_H_
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+// #define DEBUG_SHADER
+
+/* Shader Utilities */
+GLint opengl_shader_compile(GLuint *shader, GLenum type, GLsizei count, const char *content_file);
+GLint opengl_shader_link(GLuint prog);
+GLint opengl_shader_validate(GLuint prog);
+void  opengl_shader_destroy(GLuint vertShader, GLuint fragShader, GLuint prog);
+
+#endif // _OPENGL_SHADER_H_

app/src/main/jni/API/Video/opengl_stage.c

+/*
+ *  opengl_stage.c
+ *  Test
+ *
+ *  Created by Karl Leplat on 22/02/10.
+ *  Copyright 2010 Parrot SA. All rights reserved.
+ *
+ */
+#include "opengl_stage.h"
+#include "time.h"
+
+float DEBUG_fps = 0.0;
+
+extern opengl_video_stage_config_t ovsc;
+
+const vp_api_stage_funcs_t opengl_video_stage_funcs = {
+	(vp_api_stage_handle_msg_t) NULL,
+	(vp_api_stage_open_t) opengl_video_stage_open,
+	(vp_api_stage_transform_t) opengl_video_stage_transform,
+	(vp_api_stage_close_t) opengl_video_stage_close
+};
+
+C_RESULT opengl_video_stage_open(opengl_video_stage_config_t *cfg)
+{
+	vp_os_mutex_init(&cfg->mutex);
+	return C_OK;
+}
+
+C_RESULT opengl_video_stage_transform(opengl_video_stage_config_t *cfg, vp_api_io_data_t *in, vp_api_io_data_t *out)
+{
+    static struct timeval tvPrev = {0, 0}, tvNow = {0, 0};
+    static int nbFramesForCalc = 1;
+#define CALCULATE_EVERY_X_FRAMES 10
+    if (0 == --nbFramesForCalc)
+    {
+        nbFramesForCalc = CALCULATE_EVERY_X_FRAMES;
+        tvPrev.tv_sec = tvNow.tv_sec;
+        tvPrev.tv_usec = tvNow.tv_usec;
+        gettimeofday(&tvNow, NULL);
+        if (0 != tvPrev.tv_sec) // Avoid first time calculation
+        {
+            float timeDiffMillis = ((tvNow.tv_sec - tvPrev.tv_sec) * 1000.0) + ((tvNow.tv_usec - tvPrev.tv_usec) / 1000.0);
+            DEBUG_fps = (0.9 * DEBUG_fps) + (0.1 * ((1000.0 * CALCULATE_EVERY_X_FRAMES) / timeDiffMillis));
+        }
+    }
+    
+	vp_os_mutex_lock( &out->lock );
+	if(out->status == VP_API_STATUS_INIT)
+	{
+		out->status = VP_API_STATUS_PROCESSING;
+	}
+		
+	if(out->status == VP_API_STATUS_PROCESSING )
+	{
+		vp_os_mutex_lock( &cfg->mutex );
+
+		if(cfg->video_decoder->num_picture_decoded > cfg->num_picture_decoded)
+		{
+            cfg->widthImage          = cfg->video_decoder->src_picture->width;
+            cfg->heightImage         = cfg->video_decoder->src_picture->height;		
+            cfg->widthTexture        = cfg->video_decoder->dst_picture->width;
+            cfg->heightTexture       = cfg->video_decoder->dst_picture->height;
+			switch(cfg->video_decoder->dst_picture->format)
+			{
+				case PIX_FMT_RGB565:
+					cfg->bytesPerPixel		= 2;
+					cfg->format = GL_RGB;
+					cfg->type = GL_UNSIGNED_SHORT_5_6_5;
+					break;
+				
+				case PIX_FMT_RGB24:
+					cfg->bytesPerPixel		= 3;
+					cfg->format = GL_RGB;
+					cfg->type = GL_UNSIGNED_BYTE;
+					break;
+					
+				default:
+					cfg->bytesPerPixel		= 4;
+					cfg->format = GL_RGBA;
+					cfg->type = GL_UNSIGNED_BYTE;
+					break;
+			}
+			
+            if(cfg->data != in->buffers[in->indexBuffer])
+               cfg->data = in->buffers[in->indexBuffer]; 
+ 
+            cfg->num_picture_decoded = cfg->video_decoder->num_picture_decoded;
+
+			out->numBuffers  = in->numBuffers;
+			out->indexBuffer = in->indexBuffer;
+			out->buffers	 = in->buffers;
+			out->size        = in->size;
+		}
+
+		vp_os_mutex_unlock( &cfg->mutex );
+	}
+	
+	vp_os_mutex_unlock( &out->lock );
+
+	return C_OK;
+}
+
+C_RESULT opengl_video_stage_close(opengl_video_stage_config_t *cfg)
+{
+	vp_os_mutex_destroy(&cfg->mutex);
+	return C_OK;
+}
+
+opengl_video_stage_config_t* opengl_video_stage_get(void)
+{
+	return &ovsc;
+}

app/src/main/jni/API/Video/opengl_stage.h

+/*
+ *  opengl_stage.h
+ *  Test
+ *
+ *  Created by Karl Leplat on 22/02/10.
+ *  Copyright 2010 Parrot SA. All rights reserved.
+ *
+ */
+#ifndef _OPENGL_STAGE_H_
+#define _OPENGL_STAGE_H_
+#include "common.h"
+
+typedef struct _opengl_video_config_t
+{
+    video_decoder_config_t *video_decoder;
+    
+	vp_os_mutex_t mutex;
+	GLuint widthImage;
+	GLuint heightImage;
+	GLuint widthTexture;
+	GLuint heightTexture;
+	
+	GLfloat scaleModelX;
+	GLfloat scaleModelY;
+	GLfloat scaleTextureX;
+	GLfloat scaleTextureY;
+	GLuint bytesPerPixel;
+	GLenum format;
+	GLenum type;
+	void* data;
+	GLuint identifier;
+	uint32_t num_picture_decoded;
+	uint32_t num_frames;
+} opengl_video_stage_config_t;
+
+C_RESULT opengl_video_stage_open(opengl_video_stage_config_t *cfg);
+C_RESULT opengl_video_stage_transform(opengl_video_stage_config_t *cfg, vp_api_io_data_t *in, vp_api_io_data_t *out);
+C_RESULT opengl_video_stage_close(opengl_video_stage_config_t *cfg);
+
+opengl_video_stage_config_t* opengl_video_stage_get(void);
+
+extern const vp_api_stage_funcs_t opengl_video_stage_funcs;
+
+#endif // _OPENGL_STAGE_H_

app/src/main/jni/API/Video/video_stage_renderer.c

+/*
+ * video_stage_renderer.c
+ *
+ *  Created on: May 18, 2011
+ *      Author: "Dmytro Baryskyy"
+ */
+#include <android/bitmap.h>
+
+#include "common.h"
+#include "frame_rate.h"
+#include "video_stage_renderer.h"
+#include "../Callbacks/java_callbacks.h"
+
+static const char* TAG = "video_stage_renderer";
+
+static opengl_size_t screen_size;
+int video_width = 0;
+int video_height = 0;
+static bool_t recalculate_video_texture = FALSE;
+
+// Holds video data
+static uint8_t *pixbuff = NULL;
+
+opengl_scaling	 scaling;
+opengl_texture_t texture;
+
+//GLuint           program;
+static int32_t current_num_picture_decoded = 0;
+static int32_t current_num_frames = 0;
+
+opengl_size_t oldsize;
+
+
+static void printGLString(const char *name, GLenum s)
+{
+    const char *v = (const char *) glGetString(s);
+    LOGI(TAG, "GL %s = %s\n", name, v);
+}
+
+
+void parrot_video_stage_renderer_invalidate()
+{
+	recalculate_video_texture = TRUE;
+}
+
+
+void parrot_video_stage_init()
+{
+   // Left empty as OpenGL drawing is performed on java side
+}
+
+
+void parrot_video_stage_deinit()
+{
+   // Left empty as OpenGL drawing is performed on java side
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_com_parrot_freeflight_video_VideoStageRenderer_getVideoFrameNative(JNIEnv *env, jobject obj, jobject bitmap, jintArray videoSize)
+{
+	return FALSE;
+}
+
+
+

app/src/main/jni/API/Video/video_stage_renderer.h

+/*
+ * video_stage_renderer.h
+ *
+ *  Created on: May 18, 2011
+ *      Author: Dmytro Baryskyy
+ */
+
+#ifndef VIDEO_STAGE_RENDERER_H_
+#define VIDEO_STAGE_RENDERER_H_
+
+void parrot_video_stage_renderer_invalidate();
+
+#endif /* VIDEO_STAGE_RENDERER_H_ */

app/src/main/jni/API/app.h

+/*
+ * app.h
+ *
+ *  Created on: May 4, 2011
+ *      Author: Dmytro Baryskyy
+ */
+
+#ifndef APP_H_
+#define APP_H_
+
+#include <VP_Api/vp_api_thread_helper.h>
+#include <academy_common.h>
+#define STRING_BUFFER_LENGTH 512
+
+// Put 1 if you want to set thread priorities (else put 0)
+#define USE_THREAD_PRIORITIES (1)
+
+/**
+ * Priorities for each "rt" threads
+ * Must be between 15 and 43
+ * Higher means more priority
+ */
+#define AT_THREAD_PRIORITY (47)
+#define VIDEO_THREAD_PRIORITY (31)
+#define NAVDATA_THREAD_PRIORITY (31)
+#define VIDEO_RECORDER_THREAD_PRIORITY (15)
+
+
+PROTO_THREAD_ROUTINE(app_main, data);
+
+typedef enum {
+	ARDRONE_MESSAGE_UNKNOWN_ERR = -1,
+	ARDRONE_MESSAGE_CONNECTED_OK,
+	ARDRONE_MESSAGE_DISCONNECTED,
+	ARDRONE_MESSAGE_ERR_NO_WIFI
+} ardrone_engine_message_t;
+
+typedef void (*ardroneEngineCallback)(JNIEnv* /*env*/, jobject /*obj*/, ardrone_engine_message_t /*error*/);
+
+typedef struct {
+	ardroneEngineCallback callback;
+	jobject obj;
+	char app_name[STRING_BUFFER_LENGTH];
+	char user_name[STRING_BUFFER_LENGTH];
+    char root_dir[STRING_BUFFER_LENGTH];
+    char flight_dir[STRING_BUFFER_LENGTH];
+    int flight_storing_size;
+    academy_download_new_media academy_download_callback_func;
+} mobile_main_param_t;
+
+extern ardrone_info_t ardrone_info;
+
+extern void parrot_ardrone_notify_start(JNIEnv* env, jobject obj,
+		ardroneEngineCallback callback,
+		const char *appName,
+		const char *userName,
+		const char* rootdir,
+		const char* flightdir,
+		int flight_storing_size,
+		academy_download_new_media academy_download_callback_func,
+		VIDEO_RECORDING_CAPABILITY recordingCapability);
+extern void parrot_ardrone_notify_pause();
+extern void parrot_ardrone_notify_resume();
+extern void parrot_ardrone_notify_exit();
+
+PROTO_THREAD_ROUTINE(app_main, data);
+PROTO_THREAD_ROUTINE(video_stage_player, data);
+
+#endif /* APP_H_ */

app/src/main/jni/Android.mk

+#CFLAGS=-Wall -O0 -g -fPIC
+CFLAGS := -g
+include $(all-subdir-makefiles)
+

app/src/main/jni/Application.mk

+APP_PROJECT_PATH := $(LOCAL_PATH)
+APP_ABI          := armeabi armeabi-v7a
\ No newline at end of file