public void ShareScreenshot(MegacoolRecordingConfig recordingConfig,
MegacoolShareConfig shareConfig)
{
IntPtr recordingPointer = IntPtr.Zero;
if (recordingConfig != null)
{
recordingPointer = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MCLRecordingConfig)));
MCLRecordingConfig nativeRecordingConfig = GetNativeRecordingConfig(recordingConfig);
Marshal.StructureToPtr(nativeRecordingConfig, recordingPointer, false);
}
IntPtr sharePointer = IntPtr.Zero;
if (shareConfig != null)
{
sharePointer = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MCLShareConfig)));
MCLShareConfig nativeShareConfig = GetNativeShareConfig(shareConfig);
Marshal.StructureToPtr(nativeShareConfig, sharePointer, false);
}
mcl_share_screenshot(recordingPointer, sharePointer);
if (recordingConfig != null)
{
Marshal.FreeHGlobal(recordingPointer);
}
if (shareConfig != null)
{
Marshal.FreeHGlobal(sharePointer);
}
}
public void ShareScreenshot(MegacoolRecordingConfig recordingConfig,
MegacoolShareConfig shareConfig)
{
AndroidJavaObject jRecordingConfig = RecordingConfigToJavaObject(recordingConfig);
AndroidJavaObject jShareConfig = ShareConfigToJavaObject(shareConfig);
megacool.Call("shareScreenshot", CurrentActivity, null, jRecordingConfig, jShareConfig);
}
private double GetTimeBetweenCaptures(MegacoolRecordingConfig config)
{
if (config != null && config._HasFrameRate())
{
return(1.0 / config.FrameRate);
}
return(1.0 / MegacoolConfiguration.Instance.recordingFrameRate);
}
private AndroidJavaObject RecordingConfigToJavaObject(MegacoolRecordingConfig config)
{
if (config == null)
{
return(null);
}
AndroidJavaObject jConfig = new AndroidJavaObject("co.megacool.megacool.RecordingConfig");
if (config._HasRecordingId())
{
jConfig.Call <AndroidJavaObject>("id", config.RecordingId);
}
if (config._HasMaxFrames())
{
jConfig.Call <AndroidJavaObject>("maxFrames", config.MaxFrames);
}
if (config._HasFrameRate())
{
jConfig.Call <AndroidJavaObject>("frameRate", config.FrameRate);
}
if (config._HasPlaybackFrameRate())
{
jConfig.Call <AndroidJavaObject>("playbackFrameRate", config.PlaybackFrameRate);
}
if (config._HasLastFrameDelay())
{
jConfig.Call <AndroidJavaObject>("lastFrameDelay", config.LastFrameDelay);
}
if (config._HasPeakLocation())
{
jConfig.Call <AndroidJavaObject>("peakLocation", config.PeakLocation);
}
if (config.LastFrameOverlay != null)
{
jConfig.Call <AndroidJavaObject>("lastFrameOverlayAsset", config.LastFrameOverlay);
}
if (config._HasOverflowStrategy())
{
AndroidJavaClass overflowStrategyClass = new AndroidJavaClass("co.megacool.megacool.OverflowStrategy");
AndroidJavaObject jOverflowStrategy;
if (config.OverflowStrategy == MegacoolOverflowStrategy.HIGHLIGHT)
{
jOverflowStrategy = overflowStrategyClass.GetStatic <AndroidJavaObject>("HIGHLIGHT");
}
else if (config.OverflowStrategy == MegacoolOverflowStrategy.TIMELAPSE)
{
jOverflowStrategy = overflowStrategyClass.GetStatic <AndroidJavaObject>("TIMELAPSE");
}
else
{
jOverflowStrategy = overflowStrategyClass.GetStatic <AndroidJavaObject>("LATEST");
}
jConfig.Call <AndroidJavaObject>("overflowStrategy", jOverflowStrategy);
}
return(jConfig);
}
public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd)
{
if (currentRecording == null || currentRecording.isFinished)
{
MegacoolRecordingConfig mergedConfig = MergeWithDefault(config);
currentRecording = new MegacoolRecording(mergedConfig);
currentRecording.Start();
}
capturingFrame = true;
currentRecording.CaptureFrame(forceAdd);
}
/// <summary>
/// Capture a single frame.
/// </summary>
/// <description>
/// If the recording doesn't already exist it'll be created with the settings specified in the
/// config.
/// </description>
/// <param name="config">the configuration to use to create the recording, if it doesn't already
/// exist.</param>
/// <param name="forceAdd">Set to true to ensure the frame is included in the recording, even if
/// the overflow strategy otherwise would skip it. Useful for timelapse to include the last
/// frame with a score board or final state.</param>
public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd)
{
captureManager = GetManager();
if (!captureManager)
{
return;
}
captureManager.StartWrites(0);
_RenderThisFrame = true;
_platformAgent.CaptureFrame(config, forceAdd);
}
/// <summary>
/// Start customized GIF recording.
/// </summary>
/// <remarks>
/// This will keep a buffer of 50 frames (default). The frames are overwritten until <c>StopRecording</c> gets called.
/// </remarks>
/// <param name="config">Config to customize the recording.</param>
public void StartRecording(MegacoolRecordingConfig config)
{
captureManager = GetManager();
if (!captureManager)
{
return;
}
captureManager.StartWrites(GetTimeBetweenCaptures(config));
_platformAgent.StartRecording(config);
_IsRecording = true;
SafeReleaseTextureReady();
}
/// <summary>
/// Start customized GIF recording.
/// </summary>
/// <remarks>
/// This will keep a buffer of 50 frames (default). The frames are overwritten until <c>StopRecording</c> gets called.
/// </remarks>
/// <param name="config">Config to customize the recording.</param>
public void StartRecording(MegacoolRecordingConfig config)
{
config.SetDefaults();
InitializeManager();
#if UNITY_IOS && !UNITY_EDITOR
startRecordingWithConfig(config.RecordingId, new Crop(new Rect(0, 0, 0, 0)), config.MaxFrames, config.FrameRate, config.PeakLocation, config.OverflowStrategy.ToString());
#elif UNITY_ANDROID && !UNITY_EDITOR
AndroidWrapper.StartRecording(config);
#endif
_isRecording = true;
}
/// <summary>
/// Take a screenshot and share it immediately.
/// </summary>
/// <description>
/// <para>
/// This is a helper around {@link #captureFrame(View)} and {@link #share(Activity)} when you
/// only need to share a screenshot and not all the other bells and whistles for recordings.
/// </para>
/// <para>
/// This method is functionally equivalent to:
/// <code>
/// Megacool.Instance.PauseRecording();
/// string tempRecording = "random-unused-id";
/// Megacool.Instance.CaptureFrame(new MegacoolRecordingConfig {
/// RecordingId = tempRecordingId,
/// MaxFrames = 1,
/// });
/// Megacool.Instance.Share(new MegacoolShareConfig {
/// RecordingId = tempRecordingId,
/// });
/// Megacool.Instance.DeleteRecording(tempRecordingId);
/// </code>
/// Note that if this method is called while a recording is underway the screenshot is likely to
/// be missing from the share. To stay on the safe side, leave a couple hundred ms between
/// stopping a recording and sharing a screenshot.
/// </para>
/// </description>
/// <param name="recordingConfig">The recording config, or <c>null</c>. Most properties don't
/// apply to screenshots, but the last frame overlay does.</param>
/// <param name="shareConfig">The share config, or <c>null</c>.</param>
public void ShareScreenshot(MegacoolRecordingConfig recordingConfig = null,
MegacoolShareConfig shareConfig = null)
{
captureManager = GetManager();
if (captureManager)
{
// Only try to capture if we have a manager, but always call down to the SDK to make
// sure the share happens anyway
captureManager.StartWrites(0);
_RenderThisFrame = true;
}
_platformAgent.ShareScreenshot(recordingConfig, shareConfig);
}
public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd)
{
if (config == null)
{
mcl_capture_frame(IntPtr.Zero, forceAdd);
return;
}
MCLRecordingConfig nativeConfig = GetNativeRecordingConfig(config);
IntPtr pointer = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MCLRecordingConfig)));
Marshal.StructureToPtr(nativeConfig, pointer, false);
mcl_capture_frame(pointer, forceAdd);
Marshal.FreeHGlobal(pointer);
}
public void SetDefaultRecordingConfig(MegacoolRecordingConfig config)
{
if (config == null)
{
mcl_set_default_recording_config(IntPtr.Zero);
return;
}
MCLRecordingConfig nativeConfig = GetNativeRecordingConfig(config);
IntPtr pointer = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MCLRecordingConfig)));
Marshal.StructureToPtr(nativeConfig, pointer, false);
mcl_set_default_recording_config(pointer);
Marshal.FreeHGlobal(pointer);
}
public void StartRecording(MegacoolRecordingConfig config)
{
if (currentRecording != null && !currentRecording.isFinished)
{
currentRecording = persistentRecordings.Restore(config.RecordingId);
return;
}
if (!keepCompletedRecordings)
{
persistentRecordings.Clear();
}
MegacoolRecordingConfig mergedConfig = MergeWithDefault(config);
currentRecording = new MegacoolRecording(mergedConfig);
currentRecording.Start();
}
private MCLRecordingConfig GetNativeRecordingConfig(MegacoolRecordingConfig config)
{
MCLRecordingConfig nativeConfig = new MCLRecordingConfig {
overflowStrategy = -1,
maxFrames = -1,
frameRate = -1,
playbackFrameRate = -1,
peakLocation = -1.0,
lastFrameDelay = -1,
};
if (config._HasOverflowStrategy())
{
nativeConfig.overflowStrategy = (int)config.OverflowStrategy;
}
if (config._HasFrameRate())
{
nativeConfig.frameRate = config.FrameRate;
}
if (config._HasPlaybackFrameRate())
{
nativeConfig.playbackFrameRate = config.PlaybackFrameRate;
}
if (config._HasMaxFrames())
{
nativeConfig.maxFrames = config.MaxFrames;
}
if (config._HasRecordingId())
{
nativeConfig.recordingId = config.RecordingId;
}
if (config._HasPeakLocation())
{
nativeConfig.peakLocation = config.PeakLocation;
}
if (config._HasLastFrameDelay())
{
nativeConfig.lastFrameDelay = config.LastFrameDelay;
}
if (config.LastFrameOverlay != null)
{
nativeConfig.lastFrameOverlay =
Application.streamingAssetsPath + "/" + config.LastFrameOverlay;
}
return(nativeConfig);
}
MegacoolRecordingConfig MergeWithDefault(MegacoolRecordingConfig config)
{
if (config == null)
{
return(DefaultRecordingConfig);
}
MegacoolRecordingConfig merged = new MegacoolRecordingConfig();
merged.MaxFrames = config._HasMaxFrames() ? config.MaxFrames : DefaultRecordingConfig.MaxFrames;
merged.FrameRate = config._HasFrameRate() ? config.FrameRate : DefaultRecordingConfig.FrameRate;
merged.LastFrameDelay = config._HasLastFrameDelay() ? config.LastFrameDelay : DefaultRecordingConfig.LastFrameDelay;
merged.LastFrameOverlay = config.LastFrameOverlay ?? DefaultRecordingConfig.LastFrameOverlay;
merged.OverflowStrategy = config._HasOverflowStrategy() ? config.OverflowStrategy : DefaultRecordingConfig.OverflowStrategy;
merged.PeakLocation = config._HasPeakLocation() ? config.PeakLocation : DefaultRecordingConfig.PeakLocation;
merged.RecordingId = config._HasRecordingId() ? config.RecordingId : DefaultRecordingConfig.RecordingId;
merged.PlaybackFrameRate = config._HasPlaybackFrameRate() ? config.PlaybackFrameRate : DefaultRecordingConfig.PlaybackFrameRate;
return(merged);
}
public void StartRecording(MegacoolRecordingConfig config)
{
AndroidJavaObject jConfig = new AndroidJavaObject("co.megacool.megacool.RecordingConfig");
// We have to use the generic version of Call here since the Java methods are not void, even
// though we discard the return value
jConfig.Call <AndroidJavaObject>("id", config.RecordingId);
jConfig.Call <AndroidJavaObject>("maxFrames", config.MaxFrames);
jConfig.Call <AndroidJavaObject>("peakLocation", config.PeakLocation);
jConfig.Call <AndroidJavaObject>("frameRate", config.FrameRate);
jConfig.Call <AndroidJavaObject>("playbackFrameRate", config.PlaybackFrameRate);
jConfig.Call <AndroidJavaObject>("lastFrameDelay", config.LastFrameDelay);
jConfig.Call <AndroidJavaObject>("overflowStrategy", config.OverflowStrategy.ToString());
// AndroidJavaObject jCrop = new AndroidJavaObject("android.graphics.Rect",
// (int)config.Crop.xMin, (int)config.Crop.yMin, (int)config.Crop.xMax, (int)config.Crop.yMax);
// jConfig.Call<AndroidJavaObject>("cropRect", jCrop);
Android.Call("startRecording", jConfig);
}
public MegacoolRecording(MegacoolRecordingConfig config)
{
recordingId = config.RecordingId;
lastFrameDelay = config.LastFrameDelay;
playbackFrameRate = config.PlaybackFrameRate;
maxFrames = config.MaxFrames;
peakLocation = config.PeakLocation;
switch (config.OverflowStrategy)
{
case MegacoolOverflowStrategy.HIGHLIGHT:
buffer = new HighlightBuffer(this);
break;
case MegacoolOverflowStrategy.TIMELAPSE:
buffer = new TimelapseBuffer(recordingId, maxFrames);
break;
default:
buffer = new CircularBuffer(recordingId, maxFrames);
break;
}
}
private void SetupDefaultConfiguration()
{
DefaultShareConfig = new MegacoolShareConfig();
DefaultRecordingConfig = new MegacoolRecordingConfig();
}
public void SetDefaultRecordingConfig(MegacoolRecordingConfig config)
{
AndroidJavaObject jConfig = RecordingConfigToJavaObject(config);
megacool.Call("setDefaultRecordingConfig", jConfig);
}
/// <summary>
/// Capture a single frame.
/// </summary>
/// <description>
/// If the recording doesn't already exist it'll be created with the settings specified in the
/// config.
/// </description>
/// <param name="config">the configuration to use to create the recording, if it doesn't already
/// exist.</param>
public void CaptureFrame(MegacoolRecordingConfig config)
{
CaptureFrame(config, false);
}
public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd)
{
AndroidJavaObject jConfig = RecordingConfigToJavaObject(config);
megacool.Call("captureFrame", null, jConfig, forceAdd);
}
public void StartRecording(MegacoolRecordingConfig config)
{
AndroidJavaObject jConfig = RecordingConfigToJavaObject(config);
megacool.Call("startRecording", null, jConfig);
}
public void SetDefaultRecordingConfig(MegacoolRecordingConfig config)
{
}
public void StartRecording(MegacoolRecordingConfig config)
{
}
public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd)
{
}
public void ShareScreenshot(MegacoolRecordingConfig recordingConfig,
MegacoolShareConfig shareConfig)
{
ImplementationWarning("ShareScreenshot");
}
public void CaptureFrame(MegacoolRecordingConfig config, bool forceAdd)
{
recordingManager.CaptureFrame(config, forceAdd);
}
public void ShareScreenshot(MegacoolRecordingConfig recordingConfig, MegacoolShareConfig shareConfig)
{
}
public void StartRecording(MegacoolRecordingConfig config)
{
recordingManager.StartRecording(config);
}
public void SetDefaultRecordingConfig(MegacoolRecordingConfig config)
{
recordingManager.DefaultRecordingConfig = config ?? new MegacoolRecordingConfig();
}
