227 lines
7.6 KiB
Objective-C
227 lines
7.6 KiB
Objective-C
//
|
|
// VROPlatformUtil.h
|
|
// ViroRenderer
|
|
//
|
|
// Created by Raj Advani on 11/7/16.
|
|
// Copyright © 2016 Viro Media. All rights reserved.
|
|
//
|
|
|
|
#ifndef VROPlatformUtil_h
|
|
#define VROPlatformUtil_h
|
|
|
|
#include "VRODefines.h"
|
|
#include <string>
|
|
#include <memory>
|
|
#include <functional>
|
|
#include <map>
|
|
|
|
#if VRO_PLATFORM_ANDROID
|
|
|
|
#include <jni.h>
|
|
#include <android/asset_manager.h>
|
|
#include <android/asset_manager_jni.h>
|
|
#include <android/bitmap.h>
|
|
|
|
#endif
|
|
|
|
class VROImage;
|
|
enum class VROTextureInternalFormat;
|
|
|
|
#pragma mark - Platform Identification
|
|
|
|
enum class VROPlatformType {
|
|
Unknown,
|
|
AndroidGVR,
|
|
AndroidOVR,
|
|
AndroidARCore,
|
|
AndroidSceneView,
|
|
iOSCardboard,
|
|
iOSARKit
|
|
};
|
|
|
|
void VROPlatformSetType(VROPlatformType type);
|
|
VROPlatformType VROPlatformGetType();
|
|
|
|
#pragma mark - String Loading
|
|
|
|
std::string VROPlatformLoadResourceAsString(std::string resource, std::string type);
|
|
std::string VROPlatformLoadFileAsString(std::string path);
|
|
|
|
#pragma mark - Network and File Utilities
|
|
|
|
/*
|
|
Copy the given bundled resource (e.g., asset on Android, bundled resource on iOS)
|
|
to a location on the filesystem where it can be accessed through a local path.
|
|
isTemp is set to true if the file had to be copied to a temporary file.
|
|
*/
|
|
std::string VROPlatformCopyResourceToFile(std::string asset, bool *isTemp);
|
|
|
|
/*
|
|
This function is used exclusively by Android (iOS is no-op) because it makes a few assumptions:
|
|
1) key needs to have its extension removed
|
|
2) key needs be lower case
|
|
3) key needs sanitizing and have 'prohibited' character(s) removed
|
|
*/
|
|
std::string VROPlatformFindValueInResourceMap(std::string key, std::map<std::string, std::string> resourceMap);
|
|
|
|
/*
|
|
Load the given URL to a file, and return the path to the file. If the file
|
|
is temporary and must be deleted after it's processed, temp will be set to true.
|
|
If the download fails, success will be set to false.
|
|
*/
|
|
std::string VROPlatformDownloadURLToFile(std::string url, bool *temp, bool *success);
|
|
void VROPlatformDeleteFile(std::string filename);
|
|
|
|
/*
|
|
Load the file into a binary blob and return it. The returned buffer
|
|
*must* be freed by the caller!
|
|
*/
|
|
void *VROPlatformLoadFile(std::string filename, int *outLength);
|
|
|
|
#pragma mark - Image Loading
|
|
|
|
// Returns empty shared_ptr on failure
|
|
std::shared_ptr<VROImage> VROPlatformLoadImageFromFile(std::string filename, VROTextureInternalFormat format);
|
|
|
|
#if VRO_PLATFORM_ANDROID
|
|
std::shared_ptr<VROImage> VROPlatformLoadImageFromAsset(std::string asset, VROTextureInternalFormat format);
|
|
jobject VROPlatformLoadBitmapFromAsset(std::string resource, VROTextureInternalFormat format);
|
|
jobject VROPlatformLoadBitmapFromFile(std::string path, VROTextureInternalFormat format);
|
|
|
|
// Note the returned buffer *must* be freed by the caller!
|
|
void *VROPlatformConvertBitmap(jobject jbitmap, int *bitmapLength, int *width, int *height);
|
|
|
|
#endif
|
|
|
|
#pragma mark - Threading
|
|
|
|
/*
|
|
Run the given function on the rendering thread, asynchronously (this function
|
|
returns immediately).
|
|
*/
|
|
void VROPlatformDispatchAsyncRenderer(std::function<void()> fcn);
|
|
|
|
/*
|
|
Run the given function on a background thread. The thread can be pooled,
|
|
or spun up fresh. The caller should make no assumptions.
|
|
*/
|
|
void VROPlatformDispatchAsyncBackground(std::function<void()> fcn);
|
|
|
|
/*
|
|
Run the given function on the application UI thread, asynchronously.
|
|
*/
|
|
void VROPlatformDispatchAsyncApplication(std::function<void()> fcn);
|
|
|
|
/*
|
|
Flushes the task queues from calling VROPlatformDispatch* before VROPlatformUtil
|
|
was set up.
|
|
*/
|
|
void VROPlatformFlushTaskQueues();
|
|
|
|
#if VRO_PLATFORM_IOS
|
|
#import <UIKit/UIKit.h>
|
|
|
|
NSURLSessionDataTask *VROPlatformDownloadDataWithURL(NSURL *url, void (^completionBlock)(NSData *data, NSError *error));
|
|
|
|
#endif
|
|
|
|
#pragma mark - Android Setup
|
|
|
|
#if VRO_PLATFORM_ANDROID
|
|
|
|
void VROPlatformSetEnv(JNIEnv *env, jobject appContext, jobject assetManager, jobject platformUtil);
|
|
|
|
// This function was added because VROPlatformConvertBitmap can be called before the renderer
|
|
// is created and as a result, activity and assetManager hasn't been set yet. We should think
|
|
// about how to do this better.
|
|
void VROPlatformSetEnv(JNIEnv *env);
|
|
void VROPlatformReleaseEnv();
|
|
|
|
JNIEnv *VROPlatformGetJNIEnv();
|
|
jobject VROPlatformGetJavaAppContext();
|
|
jobject VROPlatformGetJavaAssetManager();
|
|
AAssetManager *VROPlatformGetAssetManager();
|
|
|
|
// Copy the given asset into a file with the same name in the cache dir.
|
|
// This enables us to load assets through routines that only take file paths,
|
|
// for testing purposes only. Not needed in prod because assets are not used
|
|
// in prod.
|
|
std::string VROPlatformCopyAssetToFile(std::string asset);
|
|
|
|
/**
|
|
* This function takes a Java Map (java.util.Map) w/ String key and values and returns
|
|
* a C++ std::map w/ std::string key and values.
|
|
*/
|
|
std::map<std::string, std::string> VROPlatformConvertFromJavaMap(jobject javaMap);
|
|
|
|
/**
|
|
* This function takes a java map of filename -> resource location and copies the resources
|
|
* to the Android cache w/ the given filename. It then returns a c++ map of filename -> download
|
|
* location.
|
|
*/
|
|
std::map<std::string, std::string> VROPlatformCopyObjResourcesToFile(jobject resourceMap);
|
|
|
|
|
|
#pragma mark - JNI Utilities
|
|
|
|
// Get the class loader from the given object
|
|
jobject VROPlatformGetClassLoader(JNIEnv *jni, jobject jcontext);
|
|
|
|
// Find a class using the class loader associated with the given object,
|
|
// typically an activity.
|
|
// This is safe to call from any thread, even those not spawned in Java
|
|
// (i.e. threads created using pthread_create).
|
|
jclass VROPlatformFindClass(JNIEnv *jni, jobject javaObject, const char *className);
|
|
|
|
// Calls a java function from native through JNI on the given jObject with the given
|
|
// functionName, methodID and desired java function parameters.
|
|
//
|
|
// Example: VROPlatformCallJavaFunction(jObj,
|
|
// "onHover",
|
|
// "(Z)V",
|
|
// isGazing);
|
|
void VROPlatformCallJavaFunction(jobject javaObject,
|
|
std::string functionName,
|
|
std::string methodID, ...);
|
|
jlong VROPlatformCallJavaLongFunction(jobject javaObject,
|
|
std::string functionName,
|
|
std::string methodID, ...);
|
|
|
|
// Helper functions for setting jObject properties through JNI from C++
|
|
void VROPlatformSetFloat(JNIEnv *env, jclass cls, jobject jObj, const char *fieldName, jfloat value);
|
|
void VROPlatformSetString(JNIEnv *env, jclass cls, jobject jObj, const char *fieldName, std::string value);
|
|
void VROPlatformSetInt(JNIEnv *env, jclass cls, jobject jObj, const char *fieldName, jint value);
|
|
void VROPlatformSetBool(JNIEnv *env, jclass cls, jobject jObj, const char *fieldName, jboolean value);
|
|
void VROPlatformSetEnumValue(JNIEnv *env, jclass cls, jobject jObj, const char *fieldName,
|
|
std::string enumClassPathName, std::string enumValueStr);
|
|
|
|
// Safely converts the given string with the provided jni environment.
|
|
std::string VROPlatformGetString(jstring string, JNIEnv *env);
|
|
|
|
#pragma mark - Android A/V
|
|
|
|
// Create a video sink on the Java side. Returns the Surface.
|
|
jobject VROPlatformCreateVideoSink(int textureId);
|
|
void VROPlatformDestroyVideoSink(int textureId);
|
|
|
|
// Get audio properties for this device.
|
|
int VROPlatformGetAudioSampleRate();
|
|
int VROPlatformGetAudioBufferSize();
|
|
|
|
extern "C" {
|
|
|
|
void Java_com_viro_core_internal_PlatformUtil_runTask(JNIEnv *env, jclass clazz, jint taskId);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#if VRO_PLATFORM_IOS || VRO_PLATFORM_ANDROID
|
|
|
|
// Returns enum of type gvr_audio_material_type
|
|
int VROPlatformParseGVRAudioMaterial(std::string property);
|
|
|
|
#endif
|
|
|
|
#endif /* VROPlatformUtil_h */
|