protected override bool Execute(string name, CefV8Value obj, CefV8Value[] arguments, out CefV8Value returnValue, out string exception)
{
exception = null;
returnValue = null;
switch (name)
{
case "sendMessage":
string inputArg_Name = arguments[0].GetStringValue();
string inputArg_Value = arguments[1].GetStringValue();
if (inputArg_Name == "Send Message To Browser")
{
CefProcessMessage processMessage = CefProcessMessage.Create(inputArg_Name);
CefListValue listValue = processMessage.Arguments;
listValue.SetString(0, inputArg_Name);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, processMessage);
}
break;
default:
returnValue = null;
break;
}
return(true);
}
public static List <dynamic> ConvertToV8List(CefListValue arguments)
{
var args = new List <dynamic>();
if (arguments != null)
{
for (var i = 0; i < arguments.Count; i++)
{
var type = arguments.GetValueType(i);
object value;
switch (type)
{
case CefValueType.Null: value = null; break;
case CefValueType.String: value = arguments.GetString(i); break;
case CefValueType.Int: value = arguments.GetInt(i); break;
case CefValueType.Double: value = arguments.GetDouble(i); break;
case CefValueType.Bool: value = arguments.GetBool(i); break;
default: value = null; break;
}
if (value != null)
{
args.Add(value);
}
}
}
return(args);
}
public object SendRequest(XrayAction action, XrayHandle thisArg, params object[] args)
{
var sqi = new ScriptableRequestInfo();
CefProcessMessage msg = null;
try
{
msg = new CefProcessMessage(CefNetApplication.XrayRequestKey);
CefListValue argList = msg.ArgumentList;
if (!argList.SetSize(3 + args.Length))
{
throw new InvalidOperationException();
}
argList.SetInt(0, sqi.RequestId);
argList.SetInt(1, (int)action);
argList.SetBinary(2, ValidateXrayHandle(thisArg).ToCfxBinaryValue());
AppendArgs(argList, 3, args);
CefFrame frame = this.Frame;
if (!frame.IsValid || frame.Identifier != _frameId)
{
throw new ObjectDeadException();
}
frame.SendProcessMessage(CefProcessId.Renderer, msg);
sqi.Wait();
return(sqi.GetResult());
}
finally
{
msg?.Dispose();
sqi.Dispose();
}
}
internal static CefV8Value Invoke(CefV8Context context, XrayObject target, CefListValue args)
{
CefV8Value func = target.Value;
CefV8Value thisArg = CastCefValueToCefV8Value(context, args.GetValue(3), out bool isNewThisArg);
int size = (int)(args.GetSize() - 4);
var xraylist = new List <int>(size);
var fnArgs = new CefV8Value[size];
try
{
for (int i = 0; i < fnArgs.Length; i++)
{
int index = (i + 4);
fnArgs[i] = CastCefValueToCefV8Value(context, args.GetValue(index), out bool isNew);
if (!isNew)
{
xraylist.Add(index);
}
}
return(func.ExecuteFunction(thisArg, fnArgs));
}
finally
{
for (int i = 0; i < fnArgs.Length; i++)
{
if (!xraylist.Contains(i))
{
fnArgs[i].Dispose();
}
}
}
}
public void MoveWebcam(string horizontal, string vertical)
{
using (CefProcessMessage message = CefProcessMessage.Create(nameof(MoveWebcam)))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, horizontal);
arguments.SetString(1, vertical);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
public void makeWebCall(string url, string scriptToInvoke)
{
using (CefProcessMessage message = CefProcessMessage.Create(nameof(makeWebCall)))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, url);
arguments.SetString(1, scriptToInvoke);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
public void LaunchFilterWindow(string channel, string sessionId)
{
using (CefProcessMessage message = CefProcessMessage.Create(nameof(LaunchFilterWindow)))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, channel);
arguments.SetString(1, sessionId);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
public void UpdateThemeSettings(string currentTheme, string settingsJson)
{
using (CefProcessMessage message = CefProcessMessage.Create(nameof(UpdateThemeSettings)))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, currentTheme);
arguments.SetString(1, settingsJson);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
public void showWebPage(string title, string webUrl)
{
using (CefProcessMessage message = CefProcessMessage.Create("ShowWebPage"))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, title);
arguments.SetString(1, webUrl);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
public void StartStreamViewStatsRecorder(string label, string jsonString)
{
using (CefProcessMessage message = CefProcessMessage.Create(nameof(StartStreamViewStatsRecorder)))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, label);
arguments.SetString(1, jsonString);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
public RenderProcessInitEventArgs(CefListValue initArgs)
{
if (initArgs == null)
{
throw new ArgumentNullException("initArgs");
}
_initArgs = initArgs;
_disposed = false;
}
/// <summary>
/// Called on the browser process IO thread after the main thread has been
/// created for a new render process. Provides an opportunity to specify extra
/// information that will be passed to
/// CefRenderProcessHandler::OnRenderThreadCreated() in the render process. Do
/// not keep a reference to |extra_info| outside of this method.
/// </summary>
/// <param name="extraInfo"></param>
protected override void OnRenderProcessThreadCreated(CefListValue extraInfo)
{
if (extraInfo == null)
{
throw new ArgumentNullException("extraInfo");
}
extraInfo.SetString(0, BaseMainApplication.Current.NativeRequestUrl);
extraInfo.SetString(1, BaseMainApplication.Current.RequestHostname);
extraInfo.SetInt(2, BaseMainApplication.Current.NativeRequestPort);
}
public void canceloemdownload(string oem, string abiValue)
{
Logger.Info("Get Call from browser of canceloemdownload oem: " + oem + ", abiValue: " + abiValue);
using (CefProcessMessage message = CefProcessMessage.Create("CancelOemDownload"))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, oem);
arguments.SetString(1, abiValue);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
protected override void OnRenderProcessThreadCreated(CefListValue extraInfo)
{
if (RenderProcessInitialize != null)
{
using (var ea = new RenderProcessInitEventArgs(extraInfo))
{
RenderProcessInitialize(this, ea);
}
}
base.OnRenderProcessThreadCreated(extraInfo);
}
public static void Set(CefV8Context context, XrayObject target, CefListValue args)
{
CefV8Value thisArg = GetSafeThisArg(context, target);
CefV8Value value = CastCefValueToCefV8Value(context, args.GetValue(4), out bool isNotXray);
thisArg.SetValueByKey(args.GetString(3), value, CefV8PropertyAttribute.None);
if (isNotXray)
{
value.Dispose();
}
}
public void EnableWebcam(string width, string height, string position)
{
using (CefProcessMessage message = CefProcessMessage.Create(nameof(EnableWebcam)))
{
Logger.Info("Got EnableWebcam");
CefListValue arguments = message.Arguments;
arguments.SetString(0, width);
arguments.SetString(1, height);
arguments.SetString(2, position);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
protected void AppendArgs(CefListValue argList, int start, IEnumerable <object> args)
{
foreach (object value in args)
{
int index = start;
start++;
if (value is V8Undefined)
{
argList.SetBinary(index, new byte[1]);
continue;
}
if (value is null)
{
argList.SetNull(index);
continue;
}
switch (value)
{
case string v:
argList.SetString(index, v);
continue;
case int v:
argList.SetInt(index, v);
continue;
case double v:
argList.SetDouble(index, v);
continue;
case bool v:
argList.SetBool(index, v);
continue;
case DateTime v:
argList.SetBinary(index, XrayHandle.FromDateTime(v).ToCfxBinaryValue());
continue;
case XrayHandle v:
argList.SetBinary(index, ValidateXrayHandle(v).ToCfxBinaryValue());
continue;
case ScriptableObject v:
argList.SetBinary(index, ValidateXrayHandle((XrayHandle)v).ToCfxBinaryValue());
continue;
}
throw new NotImplementedException("Type: " + value.GetType().Name);
}
}
/// <summary>
/// Called after the render process main thread has been created.
/// </summary>
/// <param name="extraInfo"></param>
protected override void OnRenderThreadCreated(CefListValue extraInfo)
{
if (extraInfo == null)
{
throw new ArgumentNullException("extraInfo");
}
NativeRequestUrl = extraInfo.GetString(0);
RequestHostname = extraInfo.GetString(1);
NativeRequestPort = extraInfo.GetInt(2);
GeneralLog.Info("Render process thread created.");
}
public void openapp(string appIcon, string appName, string apkUrl, string packageName)
{
Logger.Info("Get Call from browser of open App :" + appName);
using (CefProcessMessage message = CefProcessMessage.Create("InstallApp"))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, appIcon);
arguments.SetString(1, appName);
arguments.SetString(2, apkUrl);
arguments.SetString(3, packageName);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
public CefListValue AsCefListValue()
{
var result = CefListValue.Create();
if (this.Value is IList)
{
var v = (IList)this.Value;
var vList = new Object[v.Count];
v.CopyTo(vList, 0);
for (var i = 0; i < vList.Length; i++)
{
if (vList[i] is Byte[])
{
result.SetBinary(i, new JSValue(vList[i]).AsCefBinaryValue());
}
else if (vList[i] is Boolean)
{
result.SetBool(i, (Boolean)vList[i]);
}
else if (vList[i] is IDictionary)
{
result.SetDictionary(i, new JSValue(vList[i]).AsCefDictionaryValue());
}
else if (vList[i] is Single || vList[i] is Double || vList[i] is Decimal || vList[i] is UInt32 || vList[i] is UInt64 || vList[i] is Int64)
{
result.SetDouble(i, (Double)vList[i]);
}
else if (vList[i] is Byte || vList[i] is SByte || vList[i] is UInt16 || vList[i] is Int16 || vList[i] is Int32)
{
result.SetInt(i, (Int32)vList[i]);
}
else if (vList[i] is IList)
{
result.SetList(i, new JSValue(vList[i]).AsCefListValue());
}
else if (vList[i] is String)
{
result.SetString(i, (String)vList[i]);
}
else
{
result.SetNull(i);
}
}
}
return(result);
}
public void ReleaseObject(XrayHandle handle)
{
if (CefNetApplication.ProcessType == ProcessType.Renderer)
{
if (CefApi.CurrentlyOn(CefThreadId.Renderer))
{
handle.Release();
}
else
{
CefApi.PostTask(CefThreadId.Renderer, new V8CallTask(handle.Release));
}
return;
}
CefBinaryValue obj = null;
CefProcessMessage msg = null;
try
{
if (_frameId != handle.frame)
{
return;
}
obj = handle.ToCfxBinaryValue();
msg = new CefProcessMessage(CefNetApplication.XrayReleaseKey);
using (CefListValue args = msg.ArgumentList)
{
if (!args.SetSize(1))
{
return;
}
args.SetBinary(0, obj);
}
_frame.SendProcessMessage(CefProcessId.Renderer, msg);
}
finally
{
if (msg != null)
{
msg.Dispose();
}
if (obj != null)
{
obj.Dispose();
}
}
}
static XElement ToXElement(string name, CefListValue value)
{
var result = new XElement(name);
var count = value.Count;
for (int i = 0; i < count; i++)
{
var type = value.GetValueType(i);
switch (type)
{
case CefValueType.Invalid:
break;
case CefValueType.Null:
result.Add(new XElement("item", null));
break;
case CefValueType.Bool:
result.Add(new XElement("item", value.GetBool(i)));
break;
case CefValueType.Int:
result.Add(new XElement("item", value.GetInt(i)));
break;
case CefValueType.Double:
result.Add(new XElement("item", value.GetDouble(i)));
break;
case CefValueType.String:
result.Add(new XElement("item", value.GetString(i)));
break;
case CefValueType.Binary:
break;
case CefValueType.Dictionary:
result.Add(ToXElement("item", value.GetDictionary(i)));
break;
case CefValueType.List:
result.Add(ToXElement("item", value.GetList(i)));
break;
default:
break;
}
}
return(result);
}
public JSValue(CefListValue value)
{
if (value == null)
{
return;
}
var result = new List <Object>();
for (var i = 0; i < value.Count; i++)
{
switch (value.GetValueType(i))
{
case CefValueType.List:
result.Add(new JSValue(value.GetList(i)).Value);
break;
case CefValueType.Binary:
result.Add(new JSValue(value.GetBinary(i)).Value);
break;
case CefValueType.String:
result.Add(value.GetString(i));
break;
case CefValueType.Double:
result.Add(value.GetDouble(i));
break;
case CefValueType.Int:
result.Add(value.GetInt(i));
break;
case CefValueType.Bool:
result.Add(value.GetBool(i));
break;
case CefValueType.Dictionary:
result.Add(new JSValue(value.GetDictionary(i)).Value);
break;
default:
result.Add(null);
break;
}
}
this.Value = result.ToArray();
}
public void StartStreamV2(
string jsonString,
string callbackStreamStatus,
string callbackTabChanged)
{
Logger.Info("Got StartStreamV2");
using (CefProcessMessage message = CefProcessMessage.Create(nameof(StartStreamV2)))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, jsonString);
arguments.SetString(1, callbackStreamStatus);
arguments.SetString(2, callbackTabChanged);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
/// <summary>
/// Called after the render process main thread has been created.
/// </summary>
/// <param name="extraInfo"></param>
protected override void OnRenderThreadCreated(CefListValue extraInfo)
{
if (extraInfo == null)
{
throw new ArgumentNullException("extraInfo");
}
var syncProperties = JsonConvert.DeserializeObject <Dictionary <string, object> >(extraInfo.GetString(0));
foreach (var propertyName in syncProperties.Keys)
{
Application.SetSyncProperty(propertyName, syncProperties[propertyName]);
}
Logger.Info("Render process thread created.");
}
public void launchinstance(
string vmname,
string packageName,
string campaignId,
string launchMode)
{
Logger.Info("Get Call from browser of launchfarminstance vmname:" + vmname + ", campaignId: " + campaignId);
using (CefProcessMessage message = CefProcessMessage.Create("LaunchInstance"))
{
CefListValue arguments = message.Arguments;
arguments.SetString(0, vmname);
arguments.SetString(1, campaignId);
arguments.SetString(2, launchMode);
arguments.SetString(3, packageName);
CefV8Context.GetCurrentContext().GetBrowser().SendProcessMessage(CefProcessId.Browser, message);
}
}
protected void SerializeProcessMessage(PluginMessage pluginMessage, CefListValue args)
{
if (pluginMessage == null)
{
throw new ArgumentNullException("pluginMessage");
}
args.SetString(0, pluginMessage.MessageId.ToString());
args.SetInt(1, (int)pluginMessage.MessageType);
args.SetString(2, pluginMessage.PluginId);
args.SetString(3, pluginMessage.MemberName);
args.SetString(4, pluginMessage.Data);
args.SetInt(5, pluginMessage.BrowserId);
args.SetInt(6, pluginMessage.ContextId);
args.SetInt(7, (int)(pluginMessage.FrameId & uint.MaxValue)); // Lower 32 bits
args.SetInt(8, (int)(pluginMessage.FrameId >> 32)); // Upper 32 bits
args.SetString(9, pluginMessage.V8CallbackId.ToString());
}
public static long Get(CefV8Context context, XrayObject target, CefListValue args, out CefV8Value value)
{
CefV8Value thisArg = GetSafeThisArg(context, target);
CefValue arg3 = args.GetValue(3);
CefValueType valueType = arg3.Type;
if (valueType == CefValueType.Int)
{
value = thisArg.GetValueByIndex(arg3.GetInt());
return(0);
}
string name = arg3.GetString();
value = thisArg.GetValue(name);
return(0);
}
/// <summary>
/// Called on the browser process IO thread after the main thread has been
/// created for a new render process. Provides an opportunity to specify extra
/// information that will be passed to
/// CefRenderProcessHandler::OnRenderThreadCreated() in the render process. Do
/// not keep a reference to |extra_info| outside of this method.
/// </summary>
/// <param name="extraInfo"></param>
protected override void OnRenderProcessThreadCreated(CefListValue extraInfo)
{
if (extraInfo == null)
{
throw new ArgumentNullException("extraInfo");
}
var app = Application.Current;
lock (app.SyncPropertiesLock)
{
var properties = SyncProperties.ToDictionary(p => p.Key, p => p.Value.GetDelegate.DynamicInvoke(app));
extraInfo.SetString(0, JsonConvert.SerializeObject(properties));
Application.Current.RenderProcessThreadCreated = true;
}
}
static CefListValue ToListValue(CefV8Value value, CompositeDisposable disposable)
{
var result = CefListValue.Create();
var count = value.GetArrayLength();
result.SetSize(count);
for (int i = 0; i < count; i++)
{
var val = value.GetValue(i);
if (val != null)
{
if (val.IsBool)
{
result.SetBool(i, val.GetBoolValue());
}
else if (val.IsInt)
{
result.SetInt(i, val.GetIntValue());
}
else if (val.IsDouble)
{
result.SetDouble(i, val.GetDoubleValue());
}
else if (val.IsString)
{
result.SetString(i, val.GetStringValue());
}
else if (val.IsNull)
{
result.SetNull(i);
}
else if (val.IsArray)
{
result.SetList(i, ToListValue(val, disposable));
}
else if (val.IsObject)
{
result.SetDictionary(i, ToDictionaryValue(val, disposable));
}
}
}
disposable.Add(result);
return(result);
}
