bpetri / nativeload Goto Github PK

Let the Celix wrapper know when the framework is started and stopped.

The current implementation keeps track of all the bundles that are being started/stopped or installed. Implement a way that asks Celix for all the current statuses and use these.

Get the wiring up and running on the phones, so we can integrate the phones in the kubernetes-demo-cluster

after a while of running the demonstrator, some phones randomly crashed. The error said something about :

#0 addbyter 
#1 dprintf_formatf

in libdiscovery_etcd.so

The current viewer doesn't always show every phone. The logs on the phone are still correct. The viewer seems correct and it's probably the statistics_endpoint which is causing this problem. Find this problem and fix it.

xml file which describes the the artifacts, features and distributions for ace

Smarter way to do the config, some things were overwritten which we want do set manually. Might be the bug / one of the bugs why the viewer was buggy. There should also be a feature to update settings when we get a new ip.

Get the newest celix with rsa dfi to work on android.

After a while (10-20mins) the app crashes because of deadobjectexception.

In the Celix module, use bundlelisteners to sync with celix. This will be easier to use and better for overall performance.

When compiling celix/demonstrator for armv8a (aarch64) architecture it doesn't give any errors. Starting the application works without any errors.

When starting any bundle it crashes on fw_fireBundleEvent , this is strange because the framework also triggered this event when it started up. When there are no bundleEventlisteners some bundles still crash when starting(not all).

Note: armeabi-v7a and armeabi are also supported by the armv8a phones. However, this will affect the performance (not sure if it's noticeable)

Make a bundle that uses the phones sensors to set the sample rate from the producer accordingly.

Click on listitem to check checkbox. it's not very logical the way it is now.

Stabilize the viewer, demonstrator with dfi and the shakedetection bundle to be able to demonstrate this without errors.

Make a github project which contains all the bundle sources we used. (Celix & demonstrator & shakedetection) and scripts for crosscompiling this.

A script to setup ace quick. (Artifacts, features, distributions, targets based on tags) targets based on tags means that the distributions will be used for all targets with the corresponding tag. This script reads some kind of config file (xml) to setup.

After stopping celix on a device the other phones are still trying to connect to the ip from it : unable to read endpoints message every +-5 seconds. Fix this issue

Research if it's possible to communicate from another app to the celix app, so the celix app stays generic and doesn't contain any bundle specific code.

Update all the documentation so if anyone else has to work on it, it should be clear what everything does.

When a target joins ACE for the first time, you have to log in to the web ui, store the changes and retrieve them before the correct distributions get deployed

If certain bundles are active and the framework is stopped, the application crashes. This is probably due to race conditions

getExternalFilesDir() doesn't work on all devices

Crosscomple libFFI to prepare for using the newest celix with rsa dfi

modfiy current kubernetes_demonstrator to automatically deploy producers to every available 'mobile' node

Update to latest version of Celix and implement the new way of bundleListener. (No more bundle pointer, symbolic name and id are inside the event object)

Change the way you can pick your zips. Left and right fragment shall be merged

Coordinator bundle(s) to change the used tag from ace so the role can be changed and different bundles will be distributed according to this tag

Right now, the Apache Celix Android features uses ifdefs to define which code parts can be used or not. This is not the preferred way to to this.

Refactor the celix code to

• use a cmake toolchain file for cross compiling
• generate a config.h file to set up dedicated defines for not supported functionality
• check whether the not supported functionality can be extracted into separate code, so we can use the defines in the CMake Configuration but not in the source code itself.

When the deployment admin registers itself to ACE, it should give itself some tags to get the correct bundles (cpu_arch=armeabi, role=producer)

Make an easy setup with ace to distribute bundles to phones. Using the id's to tell ace which role you want.

The original idea was to create an app which can be used to demonstrate how celix can be used from embedded devices like android.

To be able to do so, we need to check whether there are licenses used which are not compatible with the Apache License and also change the inaetics-naming to an apache-naming.

prepare demo and work on our report for school. Do the two remaining interviews for the report for school.

To give a flawless demo, everything should be tested.

When starting the kubernetes-cluster-demo with only the Celix queue and without the viewer the Queue doesn't get registered in etcd.

Possibility to add artifacts through the REST client.

Coordinator which uses the stats to choose which tag to use. For instance: coordinator decides that there is a processor needed, change tag to processor and get the bundles.

Make all the correct bundles and the correct framework. Get them to run on an android phone

When a distribution2target is created with an endpoint that filters on 2 tags, it doesn't seem to work.

When starting multiple processors and producers it starts producing/processing like 1-2 samples per second. There's also a error on jsonRpc_handleReply(). in json_rpc.c

Publish the Apache Celix wrapper online so others can use it by adding a dependency in gradle.

To control the producers produce rate by movement (shaking the device), we have to use sensors. The information we retrieve from the sensors need to be processed and the producer sample rate should be set accordingly.

Research if you want to access the sensors from C or Android (communication with producer has to be from C unless this is not possible).

Separate all the Celix specific code into a Android library which handles all the communication with the framework. Users of this library will not need to know C code. This will be done on the special library branch.