I need a good way to access kernel services. There definitely will be a factory of sorts. I will need two parts. One end which runs on the kernel itself and the other end which runs on the client. When a client requests a service, the service class must be looked up and then initialized. Basically when the client requests a service it has to be checked if the service is cached and then if not the server side has to be initialized. Then once the server is initialized a connection to the client is made, a sort of context. Then following that, the IPC is linked to the client and it can then access everything as needed. So this is a bit complicated. I will need a good means of initializing services. So in effect, what I need is an interface in the system caller. Basically it returns a getter instance of a service client, where that getter can then be gotten accordingly. This way the same instance can be used and it can be hidden away behind the getter.


Definitely need a good way to manage services. Basically I will need a kind of factory which produces instances of classes accordingly.


I completely am not sure the best way to handle service creation. Services definitely will use the packet interface to communicate. I will definitely need a kind of service dispatching so packets reach the server as intended. Maybe I am going about creation the wrong way. I want to make it where the client for the most part has only a single connection for each service. Basically, I need a service web. For any services which are active within the web a connection can be made to them. I suppose in this case the way to have service servers would be to have actual ServiceLoader classes which specify server side services. Then for the client side, the client only refers to classes. The server specifies the client class for its factory. So at kernel initialization time, all of the factories are loaded, mapped, and initialized. Then the client will make an IPC request to open a connection for that single task. Event handling would then be tied to individual KernelTasks. So since the CLDC stuff is the same, I suppose that KernelTask should implement SystemTask rather than having them virtually wrapped. This would simplify things because services need to be created for each task which exists.


Using ServiceLoader is bad because it is unknown which services to actually use. There could be multiple classes trying to use the same services. It makes it easier to use, but take for example if SWM is used. Basically there could be a setup where one wants to use the filesystem to store records while another could use a byte array in some kind of RAM space. If I use the service loader then any number of those could be used for services. So what I need to do is to actually send in a map of services which should be used because there can only be a single service. This needs to be initialized with the kernel so I will need some kind of structure for initialization which says which services should be used. Basically, my own service mapping. So for stuff such as the library manager, it will need to implemented for native systems but it will vary as to which services are used. But, also additionally if there is no specific service available, I can have defaults. So effectively this ends up being a fixed set of services to enumerate for initialization. So new services will be less hard to initialize. Of course there can be system properties which specify custom services to use potentially. So this essentially is the same as mapService.


For common things, I will need an InputStream and OutputStream which are bound to each other. I can actually get away with it because PacketStream uses two threads, so it will not be an issue. The main reason is so that there is a uniform feel between the kernel and the client, especially when it comes to stuff like the IPC. Basically the kernel will be in IPC with itself, that will make things a bit easier to implement.