robius-share 0.3.0

Rust abstractions for showing native system share sheets on multiple platforms
Documentation
mod class;

use jni::{
    objects::{JObject, JObjectArray, JValueGen},
    JNIEnv,
};

use crate::{file_items, shared_text, Error, Result, ShareOptions};

const RESULT_OK: i32 = 0;
const RESULT_NO_HANDLER: i32 = 1;
const RESULT_ERROR: i32 = 2;

pub(crate) fn share(options: ShareOptions) -> Result<()> {
    validate_android_items(&options)?;

    let result =
        robius_android_env::with_activity(|env, activity| share_inner(env, activity, &options));

    match result {
        Ok(inner) => inner,
        Err(_) => Err(Error::AndroidEnvironment),
    }
}

fn validate_android_items(options: &ShareOptions) -> Result<()> {
    for file in file_items(options) {
        if let Some(path) = file.path() {
            std::fs::metadata(path)?;
        } else {
            let Some(uri) = file.uri() else {
                return Err(Error::InvalidItem);
            };
            if !uri.starts_with("content://") && !uri.starts_with("file://") {
                return Err(Error::UnsupportedItem);
            }
        }
    }
    Ok(())
}

fn share_inner(
    env: &mut JNIEnv<'_>,
    activity: &JObject<'_>,
    options: &ShareOptions,
) -> Result<()> {
    let share_class = class::get_share_class(env)?;

    let title = options
        .title
        .as_deref()
        .map(|title| env.new_string(title))
        .transpose()?;
    let subject = options
        .subject
        .as_deref()
        .map(|subject| env.new_string(subject))
        .transpose()?;
    let text = shared_text(options)
        .map(|text| env.new_string(text))
        .transpose()?;

    let files = file_items(options).collect::<Vec<_>>();
    let file_locations = files
        .iter()
        .map(|file| {
            if let Some(uri) = file.uri() {
                Ok(uri.to_owned())
            } else {
                file.path()
                    .and_then(|path| path.to_str())
                    .map(ToOwned::to_owned)
                    .ok_or(Error::InvalidItem)
            }
        })
        .collect::<Result<Vec<_>>>()?;
    let mime_types = files
        .iter()
        .map(|file| file.mime_type().map(ToOwned::to_owned))
        .collect::<Vec<_>>();

    let file_locations = string_array(env, &file_locations)?;
    let mime_types = optional_string_array(env, &mime_types)?;

    let null = JObject::null();
    let title = title.as_ref().map(|title| title.as_ref()).unwrap_or(&null);
    let subject = subject
        .as_ref()
        .map(|subject| subject.as_ref())
        .unwrap_or(&null);
    let text = text.as_ref().map(|text| text.as_ref()).unwrap_or(&null);
    let file_locations = file_locations
        .as_ref()
        .map(|locations| locations.as_ref())
        .unwrap_or(&null);
    let mime_types = mime_types
        .as_ref()
        .map(|mimes| mimes.as_ref())
        .unwrap_or(&null);

    let result = env.call_static_method(
        share_class,
        "share",
        "(Landroid/app/Activity;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;)I",
        &[
            JValueGen::Object(activity),
            JValueGen::Object(title),
            JValueGen::Object(subject),
            JValueGen::Object(text),
            JValueGen::Object(file_locations),
            JValueGen::Object(mime_types),
        ],
    )?.i()?;

    match result {
        RESULT_OK => Ok(()),
        RESULT_NO_HANDLER => Err(Error::NoHandler),
        RESULT_ERROR => Err(Error::Unknown),
        _ => Err(Error::Unknown),
    }
}

fn string_array<'a>(env: &mut JNIEnv<'a>, strings: &[String]) -> Result<Option<JObjectArray<'a>>> {
    if strings.is_empty() {
        return Ok(None);
    }

    let array = env.new_object_array(strings.len() as i32, "java/lang/String", JObject::null())?;
    for (index, string) in strings.iter().enumerate() {
        let string = env.new_string(string)?;
        env.set_object_array_element(&array, index as i32, string)?;
    }

    Ok(Some(array))
}

fn optional_string_array<'a>(
    env: &mut JNIEnv<'a>,
    strings: &[Option<String>],
) -> Result<Option<JObjectArray<'a>>> {
    if strings.is_empty() {
        return Ok(None);
    }

    let array = env.new_object_array(strings.len() as i32, "java/lang/String", JObject::null())?;
    for (index, string) in strings.iter().enumerate() {
        if let Some(string) = string {
            let string = env.new_string(string)?;
            env.set_object_array_element(&array, index as i32, string)?;
        }
    }

    Ok(Some(array))
}