MSession | sophisticated session and authentication solution | iOS library

After translating the script to c# commands as you can see below (the code snippet was adapted from here) I gpt the following error msg:

System.Management.Automation.Remoting.PSRemotingDataStructureException HResult=0x80131501 Message = An error has occurred which PowerShell cannot handle. A remote session might have ended. ... Inner Exception 1: NotSupportedException: BinaryFormatter serialization and deserialization are disabled within this application. See https://aka.ms/binaryformatter for more information.

And I found a solution for it here.

AddRange method is for add a range of value.

Use Add(item.Name)

Welcome to Stack Overflow!

First, let me recommend this recent episode of CppCast on Designing for Testing. The podcast notes that if you find your code is hard to test, it means it is too tightly coupled and is thus poorly designed.

It also (rightly, IMHO) recommends that you test only public functions. If you find yourself needing to test the private functions, you should probably refactor the code.

One way to do that is to break your code into multiple classes with the public functions you want to test. Then, your composite class can either create and own the class directly (appropriate if it's a basic type with no dependencies or complex resources of its own such as a vector or string class) or can use dependency injection to pass in the dependencies as constructor or method parameters (appropriate for databases, network connections, file systems, etc.).

Then in testing, you pass in a test double, such as a mocked object or a simplified implementation like an in-memory database instead of an out-of-process database connection, that acts like the object but does what you need in the test situation.

That's the basic advice. In your specific case, it looks like you're trying to override a non-virtual function in your TestService. What are you wanting to test exactly?

I wouldn't expect EXPECT_TRUE(service.registerCallback(SessionCallback_t)); to compile because SessionCallback_t names a type, not an instance of a type, so you can't pass it in. Again, what are you trying to accomplish?

Update to comment:

Mocking requires virtual functions (or duck typing) and dependency injection.

If you just want to test registerCallback(), I suspect you don't need a mock at all. Rather, you need to look at the function's documentation to see what it says it will do -- sometimes called the contract. For instance, what are the preconditions and postconditions of the function? What are the error cases it might encounter? These are what a unit test should cover.

For instance, does it retain only one callback (hint: as written, yes)? What happens when you call it when there is already a callback registered? Does it tolerate default-initialized std::function objects being passed in?

The bigger question is, how do you validate that your test is correct. If you start triggering notifications on your callback, you're venturing beyond the scope of testing this function in isolation. Instead, you could create an accessor class in your test to publicize what is private so you can validate. Still, you can't compare std::function for equality, so the best you can do is to invoke it and check that an expected side effect happens:

You code is not calling your drawLineButton() function, is it? Anyway, it looks like you're trying to use some things from Sceneform (MaterialFactory, ModelRenderable, etc) while doing some pure OpenGL rendering as done in the hello_ar_java.

Mixing those will result in nothing good since Sceneform uses filament as rendering engine which could use OpenGL or Vulkan. So either go fully with Sceneform or fully with OpenGL (and understand how OpenGL and Android work).

Now, if you want to continue with hello_ar_java sample, follow an OpenGL tutorial in order to be able to generate a vertex for each anchor and draw them with GL_LINES with the line size you like. Here's a good OpenGL tutorial: https://learnopengl.com/ I recommend going through all the Getting Started section, but just keep in mind that it is OpenGL and Android uses OpenGL ES, there are some differences but the computer graphics principles are the same.

They're both viable. "Better" depends on a bunch of factors such as the size of the codebase, and how many different places in the code will be wanting to use the session and device.

There's some minor overhead in sending the callback to the camera handler thread, plus more boilerplate to write, so for smaller apps, just making calls from whatever thread you're in and synchronizing appropriately works fine.

However, as your app's complexity grows, it starts becoming attractive to keep all interaction with the camera API to a single thread; not just because you don't have to synchronize explicitly, but because it's easier to reason about ownership, the state of the system, and so on, if every interaction with the camera object happens on the same thread. Also, since some of the camera API methods can block for extended time periods, you really don't want to freeze your UI for that long anyway. So sending the calls to another thread is valuable.

So it's a tradeoff of some extra boilerplate + minor overhead vs. inability to centralize camera code in one place for simplicity and smoothness.

One option is to switch to use TextureView instead of GLSurfaceView, in general view composing is much easier when using TextureView instead of GLSurfaceView.

You can enable TextureView by doing this when building a Session

Using the command line, the following commands might work:

If I were you I would put both your Audio Focus code and your Audio Player code in a ForegroundService and not the Activity, this way you can navigate to different activities, without interrupting Audio Playback. You will need to do something like that anyways if you want playback when the App is in the background.

Implementing a ForegroundService will also let you add buttons to your notification or if you are using one of the rich Audio Notification, then you can send intents directly to your ForegroundService from the buttons on the notification, rather than having to open up your App. So for your pending intents you could communicate directly with the service instead.

Also when requesting audio focus, you need to respect whether the audio focus was granted or not. Right now you are just requesting it and throwing away the result. Only if the focus was granted you should start playing back the audio.