Overview

Alius RC’s development framework is built on DJI MSDK 5.x and the proprietary Alius RC SDK. MSDK 5.x provides core capabilities for communicating with DJI hardware platforms (flight control, video transmission, gimbal, battery, etc.), while Alius RC SDK encapsulates advanced features such as telemetry data acquisition, command issuance, state synchronization, and physical button mapping on top of MSDK, helping developers achieve a more complete control experience with less code.

This guide is intended for engineers with Android development experience, assuming familiarity with Java/Kotlin, Android development fundamentals, and Gradle build tools.

Architecture Overview

┌────────────────────────────────────────────┐
│            Your Android App                 │
├────────────────────────────────────────────┤
│              Alius RC SDK                   │
│  ┌──────────┐ ┌──────────┐ ┌────────────┐  │
│  │Telemetry │ │ Command  │ │ KeyMapping │  │
│  │ Manager  │ │ Manager  │ │  Manager   │  │
│  ├──────────┤ ├──────────┤ ├────────────┤  │
│  │  Data    │ │Connection│ │    UI      │  │
│  │ Channel  │ │ Manager  │ │ Components │  │
│  └──────────┘ └──────────┘ └────────────┘  │
├────────────────────────────────────────────┤
│              DJI MSDK 5.x                   │
│  ┌──────────┐ ┌──────────┐ ┌────────────┐  │
│  │ Flight   │ │ Camera   │ │ Gimbal      │  │
│  │ Control  │ │ Manager  │ │ Manager     │  │
│  ├──────────┤ ├──────────┤ ├────────────┤  │
│  │ Battery  │ │ RTK      │ │ Perception  │  │
│  └──────────┘ └──────────┘ └────────────┘  │
├────────────────────────────────────────────┤
│          Android HAL / Hardware             │
└────────────────────────────────────────────┘

DJI MSDK 5.x Integration Steps

1. Project Dependency Configuration

Add dependencies in app/build.gradle:

android {
    compileSdkVersion 34
    defaultConfig {
        minSdkVersion 24
        targetSdkVersion 34
    }
    packagingOptions {
        exclude 'META-INF/rxjava.properties'
    }
}

dependencies {
    // DJI MSDK 5.x
    implementation 'com.dji:dji-sdk-v5-aircraft:5.10.0'
    implementation 'com.dji:dji-sdk-v5-network:5.10.0'

    // Alius RC SDK
    implementation 'com.alius-tech:alius-rc-sdk:1.2.0'

    // Common dependencies
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'io.reactivex.rxjava3:rxjava:3.1.8'
    implementation 'io.reactivex.rxjava3:rxandroid:3.0.2'
}

2. Application Initialization

Create an Application class to complete SDK registration:

public class RcApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        initDjiSdk();
    }

    private void initDjiSdk() {
        // Must call Helper.install() first to load .so libraries
        Helper.install(this);

        SDKManager.getInstance().init(this, new SDKManagerCallback() {
            @Override
            public void onRegister(DJIError error) {
                if (error == DJIError.COMMON_SUCCESS) {
                    // MSDK registration successful, initialize Alius RC SDK
                    AliusRCManager.getInstance().init(
                        RcApplication.this,
                        new AliusRCInitCallback() {
                            @Override
                            public void onSuccess() {
                                Log.i("AliusRC", "Alius RC SDK initialized");
                            }
                            @Override
                            public void onFailure(int errorCode, String msg) {
                                Log.e("AliusRC", "Init failed: " + msg);
                            }
                        }
                    );
                }
            }

            @Override
            public void onProductDisconnect(int productId) {
                // Handle disconnection
            }

            @Override
            public void onProductConnect(int productId) {
                // Handle reconnection
            }

            @Override
            public void onComponentChange(int productId, 
                BaseComponent component, ComponentChangeType type) {
                // Handle component changes
            }
        });
    }
}

3. AndroidManifest.xml Configuration

<manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
    <uses-permission android:name="android.permission.BLUETOOTH" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

    <application
        android:name=".RcApplication"
        ...>

        <meta-data
            android:name="com.dji.sdk.API_KEY"
            android:value="${DJI_APP_KEY}" />

    </application>
</manifest>

Alius RC SDK API Overview

Core Managers

Alius RC SDK is organized in a singleton manager pattern. The main classes include:

Retrieving Telemetry Data

// Subscribe to real-time telemetry data
TelemetryManager tm = AliusRCManager.getInstance().getTelemetryManager();

// Subscribe to battery info (updated per second)
tm.subscribeBatteryInfo(batteryInfo -> {
    int percent = batteryInfo.getChargeRemainingInPercent();
    double voltage = batteryInfo.getVoltage();
    double temperature = batteryInfo.getTemperature();
    updateBatteryUI(percent, voltage, temperature);
});

// Subscribe to flight/motion attitude (200 Hz update)
tm.subscribeAttitude(attitude -> {
    double roll = attitude.getRoll();
    double pitch = attitude.getPitch();
    double yaw = attitude.getYaw();
    updateAttitudeDisplay(roll, pitch, yaw);
});

// Subscribe to GPS position
tm.subscribeGPSSignal(gpsData -> {
    double lat = gpsData.getLatitude();
    double lng = gpsData.getLongitude();
    int satellites = gpsData.getSatelliteCount();
    updateGPSDisplay(lat, lng, satellites);
});

// Subscribe to velocity
tm.subscribeVelocity(velocity -> {
    double vx = velocity.getX();  // m/s
    double vy = velocity.getY();
    double vz = velocity.getZ();
    updateSpeedDisplay(vx, vy, vz);
});

Issuing Control Commands

CommandManager cm = AliusRCManager.getInstance().getCommandManager();

// Basic movement control (virtual joystick)
// x: forward/backward (-1.0 to 1.0)
// y: left/right (-1.0 to 1.0)
// z: up/down (-1.0 to 1.0)
// yaw: rotation (-1.0 to 1.0)
cm.sendMovementCommand(0.5f, 0.0f, 0.0f, 0.0f, new CommandCallback() {
    @Override
    public void onResult(CommandError error) {
        if (error == null) {
            // Command executed successfully
        } else {
            Log.e("Command", "Error: " + error.getDescription());
        }
    }
});

// Emergency brake
cm.emergencyBrake();

// Return to home (if robot supports it)
cm.startGoHome(new CommandCallback() {
    @Override
    public void onResult(CommandError error) {
        // Handle result
    }
});

// Set flight/motion mode
cm.setFlightMode(FlightMode.POSITION_HOLD, null);

Physical Button Mapping

KeyMappingManager km = AliusRCManager.getInstance().getKeyMappingManager();

// Map C1 button to "capture photo"
km.mapKey(PhysicalKey.C1, KeyAction.SINGLE_CLICK,
    () -> getCameraManager().capturePhoto(null));

// Map C2 long press to "emergency brake"
km.mapKey(PhysicalKey.C2, KeyAction.LONG_PRESS,
    () -> getCommandManager().emergencyBrake());

// Map dial wheel to gimbal pitch control
km.mapWheel(WheelDirection.CW, degrees -> {
    GimbalManager gm = getGimbalManager();
    gm.rotate(GimbalAxis.PITCH, -degrees * 0.5f, null);
});

km.mapWheel(WheelDirection.CCW, degrees -> {
    GimbalManager gm = getGimbalManager();
    gm.rotate(GimbalAxis.PITCH, degrees * 0.5f, null);
});

// Enable mapping
km.enable();

Custom Data Channel

Alius RC SDK provides a custom data transmission channel independent of the video stream, usable for robot status reporting and control parameter issuance.

DataChannelManager dcm = AliusRCManager.getInstance().getDataChannelManager();

// Register custom data type
dcm.registerDataType(1001, "CUSTOM_STATUS", CustomStatus.class);

// Send data to the robot side
SensorData data = new SensorData();
data.setTimestamp(System.currentTimeMillis());
data.setTemperature(25.6);
data.setPressure(1013.2);
dcm.sendData(1001, data, new DataCallback() {
    @Override
    public void onSuccess() {
        Log.d("DataChannel", "Data sent successfully");
    }
    @Override
    public void onFailure(int errorCode) {
        Log.e("DataChannel", "Send failed: " + errorCode);
    }
});

// Receive data reported from the robot side
dcm.subscribeData(1001, customStatus -> {
    CustomStatus status = (CustomStatus) customStatus;
    updateRobotStatusUI(status);
});

UI Component Library

Alius RC SDK provides a set of pre-built Android UI components for rapidly building remote controller operation interfaces:

Usage example:

<com.alius.rc.ui.RCJoystickView
    android:id="@+id/leftStick"
    android:layout_width="160dp"
    android:layout_height="160dp"
    app:stickMode="throttle_yaw"
    app:stickColor="#00D4FF"
    app:baseColor="#1A1A2E" />

<com.alius.rc.ui.FPVVideoView
    android:id="@+id/fpvView"
    android:layout_width="match_parent"
    android:layout_height="0dp"
    android:layout_weight="1"
    app:showOSD="true"
    app:osdPosition="top_right" />

Multi-Robot Support

Alius RC SDK supports one remote controller managing multiple robot connections simultaneously:

ConnectionManager connMgr = AliusRCManager.getInstance().getConnectionManager();

// Get all connected robots
List<RobotInfo> robots = connMgr.getConnectedRobots();

// Switch to a specific robot (default target for control commands)
connMgr.setActiveRobot("robot_serial_001");

// Listen for robot connection changes
connMgr.addConnectionListener(new ConnectionListener() {
    @Override
    public void onRobotConnected(RobotInfo robotInfo) {
        Log.i("RC", "Robot connected: " + robotInfo.getName());
    }
    @Override
    public void onRobotDisconnected(RobotInfo robotInfo) {
        Log.i("RC", "Robot disconnected: " + robotInfo.getName());
    }
});

Code Example: Complete Control Activity

The following example demonstrates a minimal runnable control Activity:

public class ControlActivity extends AppCompatActivity {

    private FPVVideoView fpvView;
    private RCJoystickView leftStick, rightStick;
    private TelemetryPanelView telemetryPanel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_control);

        fpvView = findViewById(R.id.fpvView);
        leftStick = findViewById(R.id.leftStick);
        rightStick = findViewById(R.id.rightStick);
        telemetryPanel = findViewById(R.id.telemetryPanel);

        // Bind joystick inputs to control commands
        bindSticks();
        // Start telemetry data subscription
        startTelemetry();
        // Start video feed
        fpvView.startVideoFeed();
    }

    private void bindSticks() {
        CommandManager cm = AliusRCManager.getInstance()
            .getCommandManager();

        leftStick.setOnStickListener((x, y) -> {
            // Left stick: throttle + yaw
            cm.setThrottle(y);
            cm.setYaw(x);
        });

        rightStick.setOnStickListener((x, y) -> {
            // Right stick: pitch + roll
            cm.setPitch(y);
            cm.setRoll(x);
        });
    }

    private void startTelemetry() {
        TelemetryManager tm = AliusRCManager.getInstance()
            .getTelemetryManager();

        tm.subscribeBatteryInfo(battery ->
            telemetryPanel.updateBattery(battery));

        tm.subscribeAttitude(attitude ->
            telemetryPanel.updateAttitude(attitude));

        tm.subscribeGPSSignal(gps ->
            telemetryPanel.updateGPS(gps));
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        fpvView.stopVideoFeed();
    }
}

Debugging and Logging

Alius RC SDK provides a leveled logging system:

// Set log level (DEBUG, INFO, WARN, ERROR)
AliusRCManager.getInstance().setLogLevel(LogLevel.DEBUG);

// Add custom log listener
AliusRCManager.getInstance().addLogListener((level, tag, message) -> {
    if (level == LogLevel.ERROR) {
        // Handle error log
        uploadErrorLog(tag, message);
    }
});

// Export complete logs
String logPath = AliusRCManager.getInstance().exportLogs();

During debugging, you can view real-time logs by connecting the remote controller via ADB:

adb logcat -s AliusRC:D DJISDK:D

Version Compatibility

It is recommended to always use the latest SDK version to gain the latest feature improvements and bug fixes.

Next Steps

• Integration Guide — Integrate Alius RC into a complete robot system
• Specifications — View hardware parameters
• DJI MSDK 5.x Official Documentation — Visit developer.dji.com