Category: Development

  • December 15, 2016 - Javier Martinez Canillas

    Samsung OSG Contributions to Linux Kernel 4.9

    Linux 4.9 was released on December 11, making this release the biggest to date in number of changes. In this development cycle, the Samsung Open Source Group (OSG) contributed 394 patches that modified 15,856 lines of code. Although 4 engineers contributed to different Kernel subsystems, most of the changes comes again from Mauro Carvalho Chehab’s work to improve the Linux kernel documentation. The following is a list of the OSG engineers that contributed to this release and the number of changesets and lines of code, as reported by Jonathan Corbet and Greg Kroah-Hartman’s gitdm tool. OSG developers by changesets Mauro Carvalho Chehab 238 60.4% Javier Martinez Canillas 108 27.4% Shuah Khan 24 6.1% Luis de Bethencourt 24 6.1% OSG developers by changed lines Mauro Carvalho Chehab 14,747 93.0% Javier Martinez Canillas 518 3.3% Shuah Khan 314 2.0% Luis de Bethencourt 277 1.7% OSG Contributions to This Release On this release, […]

    Read More
  • December 12, 2016 - Cedric Bail

    New Improvements to EFL Animation Management

    EFL is undergoing a huge API refactor; the goal of this change is to simplify API usage while simultaneously making it more powerful. One major component that required improvement was animation management. Legacy In the past, Ecore_Animator was the only object in charge of providing information about when to animate something; this had a few limitations and problems. The first problem is handling the lifecycle of the object: it must be manually destroyed once the animation is completed or when the object that uses it is destroyed. There was no way to link the object lifecycle with another object in any way or form. The animator object was built with the idea that there is one, and only one, global frame rate for the entire application. This is becoming less true today as moving to Wayland provides the ability to get the animation tick from the compositor on a per-window […]

    Read More
  • December 1, 2016 - Tom Hacohen

    Improving Debug Code Performance in EFL

    I work on EFL, a cross-platform graphical toolkit written in C. I recently decided to improve one aspect of the experience for developers using the API (otherwise known as users) by making EFL provide more information and stricter sanity checks when developing and debugging applications. A key requirement was ease of use. With these requirements, the solution was obvious, unfortunately obvious solutions don’t always work as well as you expect. The Obvious Solution: an Environment Variable Using an environment variable sounds like a good idea, but it comes with one major, unacceptable flaw: a significant performance impact. Unfortunately, one of the places we wanted to collect debug information was Eo, a hot-path in EFL. Believe it or not, adding a simple check to see if debug-mode is enabled was enough to degrade performance. To illustrate, consider the following code: Note: thanks to Krister Walfridsson for pointing out a mistake in […]

    Read More
  • The Linux kernel contains a set of developer unit and regression tests (Kselftests) under tools/testing/selftests; these tests exercise individual code paths in the kernel. In this blog post, I’ll explain how to build and run these tests, run Kselftest on a system it’s built on, and how to install and run tests on a target test system. Even though kselftest’s main purpose is for developer regression test, testers and users can also use it to ensure there are no regressions in a new kernel. Kselftest is run everyday on several Linux kernel trees on the 0-Day and Linux kernel integration test rings. How to Build Kselftest The tests are intended to be run after building, installing, and booting a kernel.

    Boot the new kernel, then execute the following

    Please note, some tests require root privileges. You can run a subset of selftests using “TARGETS” make command […]

    Read More
  • November 17, 2016 - Marcel Hollerbach

    An Introduction to Managing Enlightenment Widget Focus

    In Enlightenment, a widget can have focus, meaning that once a key on a keyboard is pressed the events will be delivered to the focused widget, and the widget can then react to the event. For example, a text field will start to append the letter ‘a’ once the appropriate key is hit on the keyboard; once the key is released, it will stop appending the characters. In other words, the focused widget is the widget that gets attention from input events. There can be several reasons for a widget to get focus, such as when a user clicks on it. But, there are also use cases where the user doesn’t have a touchscreen or mouse, such as on a TV, and needs to rely on a remote to control the focus on the screen. There are six directions that provide an optimal method for moving the focus around in […]

    Read More
  • Ibar has been Enlightenment’s primary launcher for at least a decade. What it lacked in features it gained in simplicity. However, as Enlightenment has grown, ibar has seemingly stayed stagnant. I wasn’t surprised when Mike Blumenkrantz informed me this would be one of the focuses of my internship. From the depths of Enlightenment’s growling, starving stomach, Luncher was born. In my previous post, I gave an introduction to developing gadgets for Enlightenment using the new gadget API; I did so by converting an existing module to the API, and this preparation was one of the first steps in creating Luncher. Mike and I spent weeks on end discussing ideas for Luncher including both necessary and wishlist features. We kicked around ideas and shared visuals of what we would like Luncher to be, and we identified weakness in ibar that must be improved for Luncher. In the end, we determined a […]

    Read More
  • After finishing high school, I was destined to continue my academic life studying one of the fine arts I always loved: Architecture. I took special art classes to get prepared to study it, and so I did; I entered the architectural school at my hometown in the Canary Islands. In their first year, all students learn about the Bauhaus school and their impact. I knew about them, but in that year I learned about their philosophy in detail and I became sanely obsessed with their work. During their difficult social/political time, Bauhaus revolutionized the world of architecture, design, and art. Their modernist designs were centered in functionality, simplicity, rationality, and taking art to everybody through mass production. In summary, making our day to day habitats and tools better, cheaper, simpler, and available to all. So through most of my first year I asked myself “Where is the present-day Bauhaus?” I […]

    Read More
  • November 9, 2016 - Michaël Bouchaud

    Samsung OSG Intern Profile: Michaël Bouchaud

    My name is Michaël Bouchaud, and over the years I’ve been a software developer with several companies; I’ve now become the most recent intern in the Samsung Open Source Group internship program. In this post, I’ll share my new activities, but first, I’ll introduce myself. How I Got My Start I’ve used Enlightenment since E16 was my desktop window manager while I was in high school. What attracted me to this environment the most is the fact that it’s lightweight and sits on the side of the interface, allowing it to be effective on both mobile and desktop. I was always a rather good math student, and I studied computer science, mathematics, physics and chemistry at university. At the end of my studies, I looked for work primarily in a Linux environment; the search was not easy, but I came across Substantiel, a little French company that works with Debian. It […]

    Read More
  • November 8, 2016 - Arun Raghavan

    GStreamer Media Synchronization Made Easy

    A lesser known, but particularly powerful feature of GStreamer is the ability to synchronize media playback across multiple devices with fairly good accuracy. However, with the way things stand right now, it requires some amount of fiddling and a reasonably thorough knowledge of GStreamer’s synchronization mechanisms. While we have had some excellent talks about these at previous GStreamer conferences, getting things to work is still a fair amount of effort for someone not well-versed with GStreamer. As part of my work with the Samsung OSG, I’ve been working on addressing this problem by wrapping all the complexity associated with this in a library. The intention is for anyone who wants to implement synchronized streaming between devices on the same network to be able to do so with a few lines of code and basic know-how of writing applications based on GStreamer. I’ve started work on this already, and you can […]

    Read More
  • November 4, 2016 - Chris Michael

    Ecore_Wl2: An EFL Library for Wayland Applications

    Throughout the years of developing Wayland support for EFL, few EFL libraries have had as much impact on EFL Wayland applications as the Ecore_Wayland library has. This library was one of the first to make it possible to truly run EFL applications in a Wayland environment. As the years progressed, it became apparent that Ecore_Wayland had some shortcomings; this blog post will introduce you to the replacement for Ecore_Wayland, called Ecore_Wl2. Ecore_Wayland’s Shortcomings While testing our first Wayland implementation, it became apparent that the initial implementation of the Ecore_Wayland library had some drawbacks. Publicly exposed structures could not be changed easily without breaking existing applications, and any changes to existing Wayland protocols would require significant changes to our Ecore_Wayland library. It was also discovered that when an EFL Wayland application creates a new window, the backend library also creates an entirely new display and connection to the Wayland server. This […]

    Read More