ohos_rust_binding 0.1.0

# ohos_rust_binding

This is a Rust language binding library for the OpenHarmony operating system, allowing developers to interact with OpenHarmony native APIs using Rust.

## Features

- Provides Rust language bindings for OpenHarmony native APIs
- Supports various OpenHarmony feature modules, including:
  - Logging system (log)
  - ArkTS callback handling (arkts_cb)
  - XComponent access (xcomponent)
  - Account management (account)
  - Resource management (asset)
  - Bundle management (bundle)
  - Drawing functionality (drawing)
  - EGL graphics interface (egl)
  - HiAppEvent events (hiappevent)
  - HiDebug debugging tools (hidebug)
  - HiTrace tracing (hitrace)
  - Input event handling (input)
  - Relational database (rdb)
  - Task scheduler (scheduler)
  - Web functionality access (web)
  - Window management (window)
- Cross-platform development support
- Type-safe API calls

## Environment Requirements

- Rust 1.60+ (latest stable version recommended)
- Cargo package manager
- OpenHarmony Native SDK

## Installation and Configuration

### 1. Set Environment Variables

Before using this library, you need to set the following environment variables:

```bash
# Set OpenHarmony Native SDK path
export OHOS_NATIVE_HOME=/path/to/ohos/native/sdk
```

### 2. Add Dependency

Add the ohos_rust_binding dependency to your Cargo.toml file:

```toml
[dependencies]
ohos_rust_binding = {
    path = "../ohos_rust_binding",
    features = ["log", "arkts_cb", "xcomponent"] # Select modules as needed
}
```

## Build Instructions

### Supported Target Platforms

The library currently supports the following target platform:
- aarch64-unknown-linux-ohos

### Build Commands

```bash
# Execute in the ohos_rust_binding directory
cargo build

# Build for a specific target platform
cargo build --target aarch64-unknown-linux-ohos
```

## Usage Examples

### Log Module Example

```rust
use ohos_rust_binding::log::*;

fn main() {
    // Output logs of different levels
    error!("This is an error log");
    warn!("This is a warning log");
    info!("This is an info log");
    debug!("This is a debug log");
    
    // Log with formatting parameters
    let app_name = "MyApp";
    info!("Application {} has started", app_name);
}
```

### XComponent Example

```rust
use ohos_rust_binding::xcomponent::*;
use napi::{CallContext, JsObject, Result};

fn get_xcomponent_id(ctx: CallContext) -> Result<JsObject> {
    // Get XComponent object from callback information
    let xcomponent = get_x_component_from_callback(ctx.env, ctx.this_unchecked())?;
    
    // Get XComponent ID
    let id = get_x_component_id(&xcomponent)?;
    
    // Process XComponent ID...
    Ok(ctx.env.create_string_from_std(id)?.into_object()?)
}
```

### ArkTS Callback Example

```rust
use ohos_rust_binding::arkts_cb::*;
use napi::{CallContext, Error, Result};

fn call_arkts_function(ctx: CallContext) -> Result<()> {
    // Assuming this is a callback function passed from JavaScript/ArkTS layer
    let callback = ctx.get::<JsFunction>(0)?;
    
    // Prepare parameters
    let params = vec![ctx.env.create_string("Hello from Rust!")?.into()];
    
    // Call ArkTS function
    match thread_safe_func_call_ark_ts(ctx.env, &callback, params) {
        Ok(_) => Ok(()),
        Err(err) => Err(Error::from_reason(format!("Failed to call ArkTS function: {}", err))),
    }
}
```

## Development Notes

1. **Platform Compatibility**:
   - On unsupported target platforms, the build process will automatically skip bindgen code generation but still allows development work in the development environment.
   - When running on unsupported platforms, relevant API calls may return errors or perform no operations.

2. **Memory Management**:
   - Pay attention to memory management differences between Rust and C when using this library
   - Avoid creating memory leaks, especially when handling C strings and pointers

3. **Asynchronous Operations**:
   - For asynchronous operations, it is recommended to use Rust's Future and async/await syntax
   - Communicate across threads through napi's thread-safe functions

## Contribution Guidelines

Contributions to this project are welcome! If you want to participate in development, please follow these steps:

1. Fork this repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## License

This project is licensed under the MIT License. See the LICENSE file for details.

## Contact

If you have any questions or suggestions, please raise them on the project's Issue page.