Google is transferring from the Java application programming interfaces (APIs) in Androids to the open source version of Oracle Java Development kit (JDK) “OpenJDK”. The news appeared on scene via “mysterious Android codebase commit” ,the news was submitted last month to the “Hacker News”. Google talked to “VentureBeat” that Android will be executing the OpenJDK rather than the Java APIs.
A Google spokesperson said that:
“Android is a collaborative efforts of open-source community and hence it is an open platform. In the upcoming release of Androids, we aim to change the Java language libraries with the OpenJDK-based approach thus, to create common code base for the developers building the apps and services. Google has been working with and contributing to the OpenJDK community since long, and aims for future to make more contributions to the project of OpenJDK.”
Supporting the development of apps in the Java programming language Android offers certain Java API libraries that are divided in two parts:
-the APIs to the libraries
-The execution codes developed by Google that makes these libraries function.
Oracle has two implementations for these two libraries:
-The open source OpenJDK version
-The proprietary JDK version
As Google is intended to conjoin its capabilities with the OpenJDK, it seems that Google is shifting from its own implementing code to the Oracle’s open-source code.
The code commit shows the change of 8902 that lucidly depicts the addition of OpenJDK code to Android.
Initial import of OpenJdk files.
Create new libcore/ojluni directory with src/main/java and src/main/native subdirectiories.
Build ojluni into core-oj jar.
Use openjdk classes from java.awt.font package.
Copy all files from jdk/src/share/classes and jdk/src/solaris/classes directories in openjdk into libcore/ojluni/src/main/java.
Copy following native files from openjdk to libcore/ojluni/src/main/native: [long list of files]
It’s just the one commit. Google has made various changes in the open-source repository regarding OpenJDK.
Android developers are likely to give positive response to the change that makes the code simple on which the apps are built. The code is common codebase for the Java API libraries rather than the multiple codebases. This may be one of the reasons of Google’s shifting to the OpenJDK but it’s not the sole reason because if it is so it could’ve been done years back.
So, when Google was asked, it pinned the last year release of Java 8 and the new features like lambdas. Google aims to concentrate all of its resources in the OpenJDK where the team can produce results more efficiently. That’s all about the developer’s stories that are quoted by Google but there are some legal narratives that can’t be left unnoticed.
It is still the question in the Hacker News users mind that whether the dispute has been settled out of court or Google found it better to protect itself regarding the Android future versions because the Oracle’s prosecution still on the go and the Google does not intend to make any comment whether the commit is related to it or not.
In august 2010 Oracle sued Google for copyright and apparent violation after acquiring Sun in January 2010. Oracle argued that “Android cannot utilize Java’s APIs without permission”. Google confound by stating that APIs cannot be copyrighted because APIs are necessary for the software development, alliance and modifications.
In May 2012, a jury ended up that Google did not breached Oracle’s patents because Java’s APIs can’t be copyrighted. Then in May 2014 the district court decision was partially reversed by the Federal Circuit in the favor of Oracle that APIs can be copyrighted. In June 2015, the U.S Supreme Court denied hearing the case and sent it to the lower court so that Google got chance to claim that it made more value out of Oracle’s copyrighted APIs.
So it is valid point to be made that after all this, Google decided to adopt the OpenJDK. Though what matters is just the end result that the further coming versions will be OpenJDK based, not the execution that’s bothering Oracle.
In any case, it still isn’t over (Google isn’t still able to exactly convert from the existing Android versions), and the final decision will be keenly observed as it is going to effect the software development greatly. If Oracle wins, the great tech powers may affect the establishment of software based on the existing services and apps and if Google wins over Oracle fair use laws can necessarily safeguard the APIs usage.
Update on December 30:
Google made some clarifications that while Google Is converting to OpenDK libraries it is still on making variations to the OpenJDK to make it work on Android because its foundation is for the standard Java libraries. As a result the forthcoming versions of Android will possess Google’s own implementation based on OpenJDK.