public AndroidAgent(
IActivityTracker activityTracker,
int contentId = -1)
{
ActivityTracker = activityTracker;
ContentId = contentId;
var displaySize = GetRealSize(Application
.Context
.GetSystemService(global::Android.Content.Context.WindowService)
.JavaCast <IWindowManager> ()
.DefaultDisplay);
Identity = new AgentIdentity(
AgentType.Android,
new Sdk(
SdkId.XamarinAndroid,
new FrameworkName(typeof(Java.Interop.Runtime)
.Assembly
.GetCustomAttribute <TargetFrameworkAttribute> ()
.FrameworkName),
Array.Empty <string> (),
"Android"),
GetApplicationName(),
deviceManufacturer: Build.Manufacturer,
screenWidth: displaySize.X,
screenHeight: displaySize.Y);
RepresentationManager.AddProvider(new AndroidRepresentationProvider());
ViewHierarchyHandlerManager.AddViewHierarchyHandler("Android", this);
}
void AssertRaw(object value, bool hasInteractiveRepresentation)
{
value.ShouldNotBeNull();
manager = new RepresentationManager(); // [SetUp] doesn't know we're looping
for (int i = 0; i < 2; i++)
{
if (i == 1)
{
manager.AddProvider(new EditAllTheThingsRepresentationProvider());
}
var valueType = value.GetType();
var reps = manager.Prepare(value);
reps.Count.ShouldEqual(hasInteractiveRepresentation ? 3 : 2);
reps.RepresentedType.ResolvedType.ShouldEqual(valueType);
reps [0].GetType().ShouldEqual(valueType);
reps [0].ShouldEqual(value);
reps.GetRepresentation(0).CanEdit.ShouldEqual(i == 1);
}
}
public EvaluationContextManager(
RepresentationManager representationManager,
object context = null)
{
RepresentationManager = representationManager
?? throw new ArgumentNullException(nameof(representationManager));
Context = context;
}
public void PublishEvaluation(
CodeCellId codeCellid,
object result,
EvaluationResultHandling resultHandling = EvaluationResultHandling.Replace)
=> MainThread.Post(() => PublishEvaluation(new Evaluation {
CodeCellId = codeCellid,
ResultHandling = resultHandling,
Result = RepresentationManager.Prepare(result)
}));
protected Agent(bool unitTestContext)
{
agentServer = new AgentServer(this);
if (!unitTestContext)
{
RepresentationManager.AddProvider(new ReflectionRepresentationProvider());
}
}
/// <summary>
/// Sets the value of the member represented by <paramref name="memberInfo"/> on the object pointed to
/// by <paramref name="handle"/>.
/// </summary>
/// <returns><c>true</c>, if member was set, <c>false</c> otherwise.</returns>
/// <param name="handle">The cache handle to the object on which we want to set a value.</param>
/// <param name="memberInfo">The member which we want to set. Can be a field or a proprety.</param>
/// <param name="value">The new value.</param>
/// <param name="returnUpdatedValue">
/// If set to <c>true</c>, set <paramref name="updatedValue"/> to the updated value of the object.
/// </param>
/// <param name="updatedValue">The updated value of the object.</param>
public bool TrySetObjectMember(
long handle,
RepresentedMemberInfo memberInfo,
object value,
bool returnUpdatedValue,
out InteractiveObject updatedValue)
{
updatedValue = null;
var translatedValue = value;
var propertyType = memberInfo.MemberType.ResolvedType;
if (value != null)
{
object convertedValue;
if (RepresentationManager.TryConvertFromRepresentation(
memberInfo.MemberType,
new [] { value },
out convertedValue))
{
translatedValue = convertedValue;
}
}
// TODO: Special handling if null value comes in for non-nullable property?
try {
if (translatedValue != null)
{
if (propertyType.IsEnum)
{
translatedValue = Enum.ToObject(propertyType, translatedValue);
}
else if (translatedValue.GetType() != propertyType)
{
translatedValue = Convert.ChangeType(translatedValue, propertyType);
}
}
} catch (InvalidCastException ice) {
Log.Error(TAG, $"Cannot convert from {translatedValue.GetType ().Name} to {propertyType.Name}");
throw ice;
}
var target = ObjectCache.Shared.GetObject(handle);
memberInfo.SetValue(target, translatedValue);
if (returnUpdatedValue)
{
updatedValue = RepresentationManager.PrepareInteractiveObject(target);
}
return(true);
}
public iOSAgent()
{
Identity = new AgentIdentity(
AgentType.iOS,
Sdk.FromEntryAssembly(SdkId.XamarinIos, "iOS"),
NSBundle.MainBundle.InfoDictionary ["CFBundleName"] as NSString,
screenWidth: (int)UIScreen.MainScreen.Bounds.Width,
screenHeight: (int)UIScreen.MainScreen.Bounds.Height);
RepresentationManager.AddProvider(new iOSRepresentationProvider());
new UnifiedNativeHelper().Initialize();
ViewHierarchyHandlerManager.AddViewHierarchyHandler("UIKit", this);
}
void AssertWordSizedNumber <T> (T [] values, WordSizedNumberFlags expectedFlags)
{
manager = new RepresentationManager(); // [SetUp] doesn't know we're looping
//#if MAC || IOS
//manager.AddProvider (new Unified.UnifiedRepresentationProvider ());
//#endif
for (int i = 0; i < values.Length; i++)
{
var reps = manager.Prepare(values [i]);
reps.Count.ShouldEqual(2);
var word = reps [0].ShouldBeInstanceOf <WordSizedNumber> ();
word.Flags.ShouldEqual(expectedFlags);
word.Value.ToString().ShouldEqual(values [i].ToString());
}
}
public WpfAgent(Func <Window> mainWindowCreator = null)
{
this.mainWindowCreator = mainWindowCreator;
latestMainWindow = mainWindowCreator?.Invoke();
if (latestMainWindow != null)
{
latestMainWindow.WindowState = WindowState.Minimized;
latestMainWindow.Show();
}
Identity = new AgentIdentity(
AgentType.WPF,
Sdk.FromEntryAssembly("WPF"),
Assembly.GetEntryAssembly().GetName().Name);
RepresentationManager.AddProvider(wpfRepresentationProvider = new WpfRepresentationProvider());
ViewHierarchyHandlerManager.AddViewHierarchyHandler("WPF", this);
}
public MacAgent()
{
#if MAC_MOBILE
var agentType = AgentType.MacMobile;
const string profile = "Modern";
#elif MAC_DESKTOP
var agentType = AgentType.MacNet45;
const string profile = "Full";
#endif
Identity = new AgentIdentity(
agentType,
Sdk.FromEntryAssembly("Xamarin.Mac", profile),
NSBundle.MainBundle.InfoDictionary ["CFBundleName"] as NSString);
RepresentationManager.AddProvider(new MacRepresentationProvider());
new UnifiedNativeHelper().Initialize();
ViewHierarchyHandlerManager.AddViewHierarchyHandler("AppKit", this);
}
public RootRenderer(RendererContext context, RenderState renderState)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (renderState == null)
{
throw new ArgumentNullException(nameof(renderState));
}
this.context = context;
this.renderState = renderState;
itemStates = ImmutableList <ItemState> .Empty;
document = context.Document;
var representedObject = renderState.Source as RepresentedObject;
if (representedObject != null)
{
foreach (var result in representedObject)
{
AppendSubrenderState(result);
}
}
else
{
if (renderState.Source != null && !(renderState.Source is JsonPayload))
{
AppendSubrenderState(RepresentationManager.ToJson(renderState.Source));
}
AppendSubrenderState(renderState.Source);
}
}
public EvaluationContextManager(RepresentationManager representationManager, object context = null);
public void SetUp()
{
manager = new RepresentationManager();
}
