Source: https://vandeverglaw.com/blog/oraclevgoogletakeaways
Timestamp: 2019-04-20 06:37:43+00:00

Document:
If you want to skip the background and history of this case, scroll down to "Takeaways."
If you are coming into this case with no preconceived notions, you might well read the court’s 56-page opinion and conclude that is a fact-centric ruling that is specific to Google, Oracle and 37 Java API packages. If you have read any of the many alarming articles about Oracle II, you might believe that copyrighted code is now “off-limits,” even if the copier’s only objective is to ensure compatibility across platforms. Neither perspective is entirely right or wrong, but in the end, the first take is the more accurate one. Because of the conflicting, circular and sometimes contradictory nature of the statutory fair use factors and judicial application thereof, fair use cases generally don’t provide precise clarity for future cases. Oracle II is no exception. Despite this, the Federal Circuit’s opinion does offer a few “takeaways” for software developers and other interested observers of copyright law.
First, a quick review of the facts.
While Oracle made the Java platform “freely available to programmers building applications… Oracle charges a licensing fee to those who want to use the APIs in a competing platform or embed them in an electronic device.” Oracle also offered a version called of Java called “OpenJDK”, which was open source. However, as with many open source platforms, “any company that improved on the packages in OpenJDK had to give away those changes for free to the Java community.” By 2005, Java had become “the leading platform for developing and running apps on mobile phones.” At issue in the litigation are 37 API packages from Java SE Version 1.4 and Version 5.0.
Feeling pressure to accelerate introduction of the Android platform (and desirable applications to run on that platform) into the exploding market for mobile phones, Google was anxious to “attract Java developers to build apps for Android.” Although Google “had been working on creating its own APIs [for Android], [it] was unable to do so successfully. Therefore, when negotiations failed, Google elected to “[d]o Java anyway and defend [its] decision, perhaps making enemies along the way.” Specifically, “Google copied verbatim the declaring code of the 37 Java API packages—11,500 lines of Oracle's copyrighted code [as well as] the SSO of the Java API packages.” However, Google did write its own implementing code.
In summary, Google used Oracle’s copyrighted Java APIs to attract developers who were familiar with those APIs into developing applications for use on Google’s competing (but incompatible) platform (Android), thereby shortening Android’s development cycle and time-to-market at a critical stage in the growth of the market for mobile device applications.
The court’s holdings in Oracle II can’t be fully understood without the context provided by the Federal Circuit’s 2014 opinion in the initial appeal Oracle brought before the court, Oracle Am., Inc. v. Google Inc., 750 F.3d 1339 (Fed. Cir. 2014)(“Oracle I”). There, the Federal Circuit concluded that the declaring code and the SSO of the 37 Java API packages at issue were entitled to copyright protection, reversing the initial decision of the district court, which found that the code and SSO were not copyrightable. Google’s fair use defense was considered but remanded to the district Court for further factfinding (setting up Oracle II).
The district court had found that the declaring code was not copyrightable because, in the Java programming language, “there was only one way to write the declaring code for each of the Java packages.” Therefore, in copyright law terms, the idea (the method declared) and its expression (the declaring code itself) merged into one, and the declaring code was rendered non-copyrightable: because methods per se are not subject to copyright. For the district court, the Java declaring code was the method, and the corresponding implementing code was the expression. In this paradigm, only the implementing code was subject to copyright; but in this case Google had written its own implementing code.
The district court relied on two Ninth Circuit cases—Sega and Sony—which, it found, were “close analogies” to the case before it, and dictated that “interface procedures that were necessary to duplicate in order to achieve interoperability were functional aspects not copyrightable under Section 102(b) [of the Copyright Act].” In Sega, the Ninth Circuit found fair use where defendant reverse-engineered console video games to discover the hidden key to interoperability set up by the console manufacturers to limit the creation of games by independent developers; and in Sony, that same court found fair use where defendant reverse-engineered a game console manufacturer’s software in order to design its own software to let consumers play those same games on their personal computers.
On remand from Oracle I, the district court bifurcated the issue of fair use from the issue of damages. The court then presided over a lengthy trial on the issue of fair use, after which the jury determined that Google’s use of the Java APIs was a fair use. Oracle filed a motion for judgment as a matter of law (“JMOL”), arguing that the jury could not have reached its verdict lawfully, and a motion for a new trial, but the court denied both motions and entered judgement against Oracle on June 8, 2016. Oracle then filed an appeal with the Federal Circuit from the district court’s judgment and rulings on the motions, which appeal became Oracle II.
The Federal Circuit’s opinion in Oracle II begins with a recitation of fair use law. Under section 107 of the Copyright Act, 17 USC § 107, et seq., courts may permit the use of copyrighted material by someone other than the copyright holder, on a case-by-case basis, if that use is found to be a “fair use.” Determining whether there is a “fair use” depends on the court’s consideration of statutory fair use examples and a non-exhaustive list of statutory factors, in addition to any other factors courts deem relevant.
In addition, “[t]he fact that a work is unpublished shall not itself bar a finding of fair use if such finding is made upon consideration of all the above factors.” With all of these factors in play, and no procedure for balancing them, small wonder it is that the outcomes in fair use cases can seem (and perhaps simply are) maddeningly unpredictable.
The Federal Circuit found that there was a commercial purpose behind Google’s copying; but also found this factor to be of limited importance. “Use of the copyrighted work that is commercial tends to weigh against a finding of fair use,” the court found, but then cautioned “[s]ince many, if not most, secondary users seek at least some measure of commercial gain from their use, unduly emphasizing the commercial motivation of a copier will lead to an overly restrictive view of fair use.” The court noted that “the fact that Android is free of charge does not make Google's use of the Java API packages noncommercial” because “although Google maintains that its revenue flows from advertisements, not from Android, commerciality does not depend on how Google earns its money… [d]irect economic benefit is not required to demonstrate a commercial use."
Google use of the API packages in the smartphone context was not new or otherwise transformative.
[T]he record showed that Java SE APIs were in smartphones before Android entered the market. Specifically, Oracle presented evidence that Java SE was in SavaJe mobile phones and that Oracle licensed Java SE to other smartphone manufacturers, including Danger and Nokia. Because the Java SE was already being used in smartphones, Google did not "transform" the copyrighted material into a new context and no reasonable jury could conclude otherwise.
The fourth factor includes both “harm to the actual or potential market for the copyrighted work, but also harm to the market for potential derivative uses, including those that creators of original works would in general develop or license others to develop.” Put another way, “a copyright holder has the exclusive right to determine when, whether and in what form to release the copyrighted work into new markets, whether on its own or via a licensing agreement.” Thus, if Google’s copying injured the actual market for Oracle’s code, or even a potential market which Oracle may have wished to enter, Oracle prevails on the fourth factor.
But even if Oracle was not actually in the market for mobile devices, the district court “should have considered how Google's copying affected potential markets Oracle might enter or derivative works it might create or license others to create.” Finally, “the fact that Oracle and Google engaged in lengthy licensing negotiations demonstrates that Oracle was attempting to license its work for mobile devices, including smartphones. Smartphones were, therefore, a "traditional, reasonable, or likely to be developed market." In the Federal Circuit’s estimation, Google was doubly-damned on the fourth factor: it usurped Oracle’s actual and potential position in the market for mobile devices.
Fair use law doesn’t specify how a court is meant to balance its findings on the four factors. Left to its own devices, courts generally wrap up their opinions with a ‘balancing’ section, wherein each court reveals how it saw the law and the facts coming together, and which factors ultimately controlled the outcome.
Although Google could have furthered copyright's goals of promoting creative expression and innovation by developing its own APIs, or by licensing Oracle's APIs for use in developing a new platform, it chose to copy Oracle's creative efforts instead. There is nothing fair about taking a copyrighted work verbatim and using it for the same purpose and function as the original in a competing platform.
Android's release effectively replaced Java SE as the supplier of Oracle's copyrighted works and prevented Oracle from participating in developing markets. This superseding use is inherently unfair.
On this record, factors one and four weigh heavily against a finding of fair use, while factor two weighs in favor of such a finding and factor three is, at best, neutral. Weighing these factors together, we conclude that Google's use of the declaring code and SSO of the 37 API packages was not fair as a matter of law.
In sum, Google’s failure to establish that its use was transformative (factor 1), and its clear ambition to usurp Java’s potential role in the mobile device market (factor 4) outweighed the relatively functional, and thus less-protected, nature of the Java APIs (factor 2), while the amount and substantiality of the material copied (factor 3) favored neither side.
We do not conclude that a fair use defense could never be sustained in an action involving the copying of computer code. Indeed, the Ninth Circuit has made it clear that some such uses can be fair.
Oracle II will have enormous implications for Google and Oracle, but its impact on the software development community is less obvious.
(6) À la Sega and Sony, reverse-engineering code, then expressing the same functionality with different code, can be fair use.
Simply put, the Federal Circuit thought Google’s use of the Java APIs was more about convenience and time-to-market objectives and less about innovation, which is the overarching goal of copyright law.
While the term can mean different things to different people, it is fair to say that the Java API license at issue in this litigation was not “open source”—it was a complex scheme designed to permit some uses, restrict others and capitalize on yet others. It permitted use in applications for free; but required royalties for use in competing platforms or installations embedded in physical devices. Viewed in this light, Oracle II can be seen as a win for platform developers that aim to use open-source elements to entice a community of developers, but simultaneously maintain enough licensing restrictions to prevent a rival platform from reaping the benefits of the community’s development activity. True, Google forged ahead and usurped that community despite Oracle’s restrictions, but if the court’s opinion holds up, Oracle is in line for a big payday.
Incredibly, Google attempted to present evidence that Oracle in 2008 moved the contested Java APIs into OpenJDK, the open-source version of Java, but the evidence was denied as being presented too late for Oracle to effectively respond.  Had Google been permitted to use this evidence, which appears to show that the disputed APIs were freely available to Google without restriction, the case would likely have resulted in a very different outcome. First, Google conceivably could have used this evidence to show that it complied with OpenJDK’s open-source license, thereby obviating the entire copyright/fair use analysis. Second, even if Google technically violated the terms of the open-source license, the court’s entire analysis on factor four (impact on the market for the copyrighted material) would be much less potent in an open source environment, since copying of open source code cannot be said to harm the original developer’s prospects for commercially exploiting said code. Presumably, in an open source platform the developer could not have reasonably had any such prospects. This wrinkle in the case should give software developers that use bits of third-party open-source code some measure of comfort.
(1) Google will file a petition for rehearing en banc, asking the entire Federal Circuit bench (18 judges) to reconsider the opinion of the 3-judge panel that decided Oracle II. The panel has granted Google an extension to May 29, 2018 (the day after Memorial Day) to file such its petition. If the petition is granted, the full court could order a new round of briefing, fresh oral argument and the court could revisit some or all of the panel’s March 27 opinion.
(2) assuming the petition for rehearing en banc is denied (as are the vast majority of such petitions), Google will likely file a petition for a writ of certiorari to the Supreme Court, asking the high court to review and overturn Oracle II. The criteria for certiorari are (a) an issue of national importance; and/or (b) a split among the circuits on a significant legal issue. It seems unlikely that the Supreme Court will take up the case, having previously declined taking up Oracle I, but it is possible.
(3) The Ninth Circuit could, in a future case, seek to clarify and/or correct the Federal Circuit’s take on its positions relative to fair use. The Federal Circuit only heard Oracle I and II because Oracle’s original suit against Google included a patent claim (over which the Federal Circuit has exclusive jurisdiction). Because Oracle filed suit in California, the appeal would have (but for the patent claim) gone to the Ninth Circuit, and so the Federal Circuit was bound to apply Ninth Circuit law to the remaining copyright claim.
(4) If and when a trial on damages proceeds at the district court, Google will likely refashion many of its arguments that from Oracle II to mitigate or exclude damages. For example, Google might well argue that Oracle’s actual presence in the market for mobile devices was so tenuous, that usurping the Java APIs did little actual financial damage to Oracle. Further, Google might just get that OpenJDK evidence into the record, in which case it can argue that Oracle, by making the APIs available to all under an open-source license, had no intention of exploiting the APIs for commercial gain.
 Oracle Am., Inc. v. Google LLC, 2018 U.S. App. LEXIS 7794 (Mar. 27, 2018).
 Oracle Am., Inc. v. Google Inc., 2016 U.S. Dist. LEXIS 74931 (Jun. 8, 2016); and Oracle Am., Inc. v. Google Inc., 2016 U.S. Dist. LEXIS 145601 (Sept. 27, 2016).
 The fair use defense is codified at 17 U.S.C. § 107.
 For example, the Electronic Frontier Foundation recently posted an article lambasting Oracle II as “a surprising decision that should terrify software developers” and that “upended decades of software industry practice and created legal uncertainty that will chill innovation.” Federal Circuit Continues to Screw Up Copyright Law and Thwart Innovation, by Corynne McSherry (Mar. 27, 2018). https://www.eff.org/deeplinks/2018/03/federal-circuit-continues-screw-copyright-law-and-thwart-innovation.
 As the court observed, “the doctrine of fair use has long been considered ‘the most troublesome in the whole law of copyright,’” quoting, Dellar v. Samuel Goldwyn, Inc., 104 F.2d 661, 662 (2d Cir. 1939).
 Oracle Am., Inc. v. Google Inc., 750 F.3d 1339, 1381 (Fed. Cir. 2014)(“Oracle I”).
 Id., and see, 17 U.S.C. § 102(b)(“In no case does copyright protection for an original work of authorship extend to any idea, procedure, process, system, method of operation, concept, principle, or discovery, regardless of the form in which it is described, explained, illustrated, or embodied in such work.”).
 The court noted that Lotus was taken up by the Supreme Court, which then proved unable to render an opinion in the case. Lotus Development Corp. v. Borland International, Inc., 49 F.3d 807 (1st Cir. 1995), aff'd without opinion by equally divided court, 516 U.S. 233, 116 S. Ct. 804, 133 L. Ed. 2d 610 (1996).
 Id., quoting, Amicus Curiae Brief of Ralph Oman, former Register of Copyrights of the United States.
 See generally, Oracle II, at 20-23.
 Before the District Court, Oracle claimed $8.8 Bn in damages. And that figure did not even include Oracles’ claim for damages based on additional uses of Android, which were remanded for findings on liability. Oracle II, at 71.
 Oracle Am., Inc. v. Google Inc., 2016 U.S. Dist. LEXIS 145601, *17-18, 101 Fed. R. Evid. Serv. (Callaghan) 670 (“[A] pretrial ruling obtained by Oracle excluded evidence tendered by Google with respect to Android Nougat. Significantly, this evidence would have shown that (back in 2008) all of the accused APIs could simply have been taken from OpenJDK, Sun's own open-source version of Java, apparently in full compliance with the open-source license. Put differently, Sun itself had given away Java (including all of the lines of code in suit) in 2008 via its open-source OpenJDK. In 2015, Google used OpenJDK to reimplement the Java APIs for the latest release of Android, which it called Nougat. Google wished to use this evidence under the fourth fair use factor to show that its infringement did no more market harm than Sun itself had already invited via its own OpenJDK release. Despite its importance, the Court excluded this development because it had not been presented by Google in time for effective rebuttal by Oracle. This exclusion was a major win for Oracle in the weeks leading up to trial.”).

References: v. 
 § 107
 v. 
 v. 
 v. 
 § 107
 v. 
 v. 
 § 102
 v. 
 v.