swapper | UI navigation and transition utility

Thank you to everyone who responded. You all were right about it trying to access more elements than there was memory allocated for the array. I found the main culprit in my largestMobile function. Here is the refactored code:

I removed the plugins id version in the root build.gradle, and now it can be compiled.

You have 2 similar questions (The opinion that the scheduler built into the kernel is the program and the opinion that it is the process and I want to know how to implement the cpu scheduling process in Linux operating system) so I'll answer for both of these here.

The answer is that it doesn't work that way at all. The scheduler is not called by user mode processes by using system calls. The scheduler isn't a system call. There are timers that are programmed to throw interrupts after some time has elapsed. Timers are accessed using registers that are memory in RAM often called memory mapped IO (MMIO). You write to some position in RAM specified by the ACPI tables (https://wiki.osdev.org/ACPI) and it will allow to control the chips in the CPU or external PCI devices (PCI is everything nowadays).

When the timer reaches 0, it will trigger an interrupt. Interrupts are thrown by hardware (the CPU). The CPU thus includes special mechanism to let the OS determine the position at which it will jump on interrupt (https://wiki.osdev.org/Interrupt_Descriptor_Table). Interrupts are used by the CPU to notify the OS that an event happened. Without interrupts, the OS would have to reserve at least one core of the processor for a special kernel process that would constantly poll the registers of peripherals and other things. It would be impossible to implement. Also, if user mode processes did the scheduler system call by themselves, the kernel would be slave to user mode because it wouldn't be able to tell if a process is finished and processes could be selfish over CPU time.

I didn't look at the source code but I think the scheduler is also often called on some IO completion (also on interrupt but not always on timer interrupt). I am quite sure that the scheduler must not be preempted. That is interrupts (and other things) will be disabled while the schedule() function runs.

I don't think you can call the scheduler a process (not even a kernel thread). The scheduler can be called by kernel threads that are created by interrupts due to bottom half processing. In bottom half processing, the top "half" of the interrupt handler runs fast and efficiently while the bottom "half" is added to the queue of processes and runs when the scheduler decides it should be scheduled. This has the effect of creating some kernel threads. The scheduler can thus be called from kernel threads but not always from bottom half of interrupts. There has to be a mechanism to call the scheduler without the scheduler having to schedule the task itself. Otherwise, the kernel will stop functioning.

So I'd recommend against using a random library on github that hasn't been updated in 4 years. In fact I'd recommend against using a random library on github at all unless you've read every line of code and done a security audit (as well as one on any weird library it drags in). But if you're going to do this, I'd suggest you just take the source code of their library and drop it into your project, rather than try to use it as a library. It's not like you'll be missing out on updates, and it will be easier than fixing a 4 year old gradle system.

Go to your SDK Manager and download the NDK by following this instruction.

Find out the location of your NDK by following this instruction.

And specify it in your app's build.gradle file, like this-

You shouldn’t delete gradle files. Why did you delete those files? However At this point I’d delete the whole project and recreate a new one copy/pasting your code.

Convert this:

It was a legacy project and building it with an old version of gradle did the trick...

Hmm... it looks like the used groovy implementation cannot handle Java17 classes (major version 61) but uses ASM to decompile (maybe for analysis).

Looking at https://docs.gradle.org/current/userguide/compatibility.html it looks like you need at least gradle version 7.3 to have JDK17 supported.

Looking at your stacktrace I am not sure if the problem is the used gradle version (<7.3) by yourself, or if the problem lies inside the used eclipse plugin.

Just change your gradle version used inside ./gradle/wrapper/gradle-wrapper.properties - or if you do not use a wrapper (which is highly recommended!) you must update your local gradle installation.

To verify it's working at least from command line you should do