1// Copyright 2018 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package java
16
17import (
18	"fmt"
19	"path"
20	"strconv"
21	"strings"
22
23	"github.com/google/blueprint/proptools"
24
25	"android/soong/android"
26	"android/soong/genrule"
27)
28
29func init() {
30	RegisterPrebuiltApisBuildComponents(android.InitRegistrationContext)
31}
32
33func RegisterPrebuiltApisBuildComponents(ctx android.RegistrationContext) {
34	ctx.RegisterModuleType("prebuilt_apis", PrebuiltApisFactory)
35}
36
37type prebuiltApisProperties struct {
38	// list of api version directories
39	Api_dirs []string
40
41	// Directory containing finalized api txt files for extension versions.
42	// Extension versions higher than the base sdk extension version will
43	// be assumed to be finalized later than all Api_dirs.
44	Extensions_dir *string
45
46	// The next API directory can optionally point to a directory where
47	// files incompatibility-tracking files are stored for the current
48	// "in progress" API. Each module present in one of the api_dirs will have
49	// a <module>-incompatibilities.api.<scope>.latest module created.
50	Next_api_dir *string
51
52	// The sdk_version of java_import modules generated based on jar files.
53	// Defaults to "current"
54	Imports_sdk_version *string
55
56	// If set to true, compile dex for java_import modules. Defaults to false.
57	Imports_compile_dex *bool
58
59	// If set to true, allow incremental platform API of the form MM.m where MM is the major release
60	// version corresponding to the API level/SDK_INT and m is an incremental release version
61	// (e.g. API changes associated with QPR). Defaults to false.
62	Allow_incremental_platform_api *bool
63}
64
65type prebuiltApis struct {
66	android.ModuleBase
67	properties prebuiltApisProperties
68}
69
70func (module *prebuiltApis) GenerateAndroidBuildActions(ctx android.ModuleContext) {
71	// no need to implement
72}
73
74// parsePrebuiltPath parses the relevant variables out of a variety of paths, e.g.
75// <version>/<scope>/<module>.jar
76// <version>/<scope>/api/<module>.txt
77// *Note when using incremental platform API, <version> may be of the form MM.m where MM is the
78// API level and m is an incremental release, otherwise <version> is a single integer corresponding to the API level only.
79// extensions/<version>/<scope>/<module>.jar
80// extensions/<version>/<scope>/api/<module>.txt
81func parsePrebuiltPath(ctx android.LoadHookContext, p string) (module string, version string, scope string) {
82	elements := strings.Split(p, "/")
83
84	scopeIdx := len(elements) - 2
85	if elements[scopeIdx] == "api" {
86		scopeIdx--
87	}
88	scope = elements[scopeIdx]
89	if scope != "core" && scope != "public" && scope != "system" && scope != "test" && scope != "module-lib" && scope != "system-server" {
90		ctx.ModuleErrorf("invalid scope %q found in path: %q", scope, p)
91		return
92	}
93	version = elements[scopeIdx-1]
94
95	module = strings.TrimSuffix(path.Base(p), path.Ext(p))
96	return
97}
98
99// parseFinalizedPrebuiltPath is like parsePrebuiltPath, but verifies the version is numeric (a finalized version).
100func parseFinalizedPrebuiltPath(ctx android.LoadHookContext, p string, allowIncremental bool) (module string, version int, release int, scope string) {
101	module, v, scope := parsePrebuiltPath(ctx, p)
102	if allowIncremental {
103		parts := strings.Split(v, ".")
104		if len(parts) != 2 {
105			ctx.ModuleErrorf("Found unexpected version '%v' for incremental prebuilts - expect MM.m format for incremental API with both major (MM) an minor (m) revision.", v)
106			return
107		}
108		sdk, sdk_err := strconv.Atoi(parts[0])
109		qpr, qpr_err := strconv.Atoi(parts[1])
110		if sdk_err != nil || qpr_err != nil {
111			ctx.ModuleErrorf("Unable to read version number for incremental prebuilt api '%v'", v)
112			return
113		}
114		version = sdk
115		release = qpr
116		return
117	}
118	release = 0
119	version, err := strconv.Atoi(v)
120	if err != nil {
121		ctx.ModuleErrorf("Found finalized API files in non-numeric dir '%v'", v)
122		return
123	}
124	return
125}
126
127func prebuiltApiModuleName(mctx android.LoadHookContext, module, scope, version string) string {
128	return fmt.Sprintf("%s_%s_%s_%s", mctx.ModuleName(), scope, version, module)
129}
130func createImport(mctx android.LoadHookContext, module, scope, version, path, sdkVersion string, compileDex bool) {
131	props := struct {
132		Name        *string
133		Jars        []string
134		Sdk_version *string
135		Installable *bool
136		Compile_dex *bool
137	}{
138		Name:        proptools.StringPtr(prebuiltApiModuleName(mctx, module, scope, version)),
139		Jars:        []string{path},
140		Sdk_version: proptools.StringPtr(sdkVersion),
141		Installable: proptools.BoolPtr(false),
142		Compile_dex: proptools.BoolPtr(compileDex),
143	}
144	mctx.CreateModule(ImportFactory, &props)
145}
146
147func createApiModule(mctx android.LoadHookContext, name string, path string) {
148	genruleProps := struct {
149		Name *string
150		Srcs []string
151		Out  []string
152		Cmd  *string
153	}{}
154	genruleProps.Name = proptools.StringPtr(name)
155	genruleProps.Srcs = []string{path}
156	genruleProps.Out = []string{name}
157	genruleProps.Cmd = proptools.StringPtr("cp $(in) $(out)")
158	mctx.CreateModule(genrule.GenRuleFactory, &genruleProps)
159}
160
161func createCombinedApiFilegroupModule(mctx android.LoadHookContext, name string, srcs []string) {
162	filegroupProps := struct {
163		Name *string
164		Srcs []string
165	}{}
166	filegroupProps.Name = proptools.StringPtr(name)
167
168	var transformedSrcs []string
169	for _, src := range srcs {
170		transformedSrcs = append(transformedSrcs, ":"+src)
171	}
172	filegroupProps.Srcs = transformedSrcs
173	mctx.CreateModule(android.FileGroupFactory, &filegroupProps)
174}
175
176func createLatestApiModuleExtensionVersionFile(mctx android.LoadHookContext, name string, version string) {
177	genruleProps := struct {
178		Name *string
179		Srcs []string
180		Out  []string
181		Cmd  *string
182	}{}
183	genruleProps.Name = proptools.StringPtr(name)
184	genruleProps.Out = []string{name}
185	genruleProps.Cmd = proptools.StringPtr("echo " + version + " > $(out)")
186	mctx.CreateModule(genrule.GenRuleFactory, &genruleProps)
187}
188
189func createEmptyFile(mctx android.LoadHookContext, name string) {
190	props := struct {
191		Name *string
192		Cmd  *string
193		Out  []string
194	}{}
195	props.Name = proptools.StringPtr(name)
196	props.Out = []string{name}
197	props.Cmd = proptools.StringPtr("touch $(genDir)/" + name)
198	mctx.CreateModule(genrule.GenRuleFactory, &props)
199}
200
201// globApiDirs collects all the files in all api_dirs and all scopes that match the given glob, e.g. '*.jar' or 'api/*.txt'.
202// <api-dir>/<scope>/<glob> for all api-dir and scope.
203func globApiDirs(mctx android.LoadHookContext, p *prebuiltApis, api_dir_glob string) []string {
204	var files []string
205	for _, apiver := range p.properties.Api_dirs {
206		files = append(files, globScopeDir(mctx, apiver, api_dir_glob)...)
207	}
208	return files
209}
210
211// globExtensionDirs collects all the files under the extension dir (for all versions and scopes) that match the given glob
212// <extension-dir>/<version>/<scope>/<glob> for all version and scope.
213func globExtensionDirs(mctx android.LoadHookContext, p *prebuiltApis, extension_dir_glob string) []string {
214	// <extensions-dir>/<num>/<extension-dir-glob>
215	return globScopeDir(mctx, *p.properties.Extensions_dir+"/*", extension_dir_glob)
216}
217
218// globScopeDir collects all the files in the given subdir across all scopes that match the given glob, e.g. '*.jar' or 'api/*.txt'.
219// <subdir>/<scope>/<glob> for all scope.
220func globScopeDir(mctx android.LoadHookContext, subdir string, subdir_glob string) []string {
221	var files []string
222	dir := mctx.ModuleDir() + "/" + subdir
223	for _, scope := range []string{"public", "system", "test", "core", "module-lib", "system-server"} {
224		glob := fmt.Sprintf("%s/%s/%s", dir, scope, subdir_glob)
225		vfiles, err := mctx.GlobWithDeps(glob, nil)
226		if err != nil {
227			mctx.ModuleErrorf("failed to glob %s files under %q: %s", subdir_glob, dir+"/"+scope, err)
228		}
229		files = append(files, vfiles...)
230	}
231	for i, f := range files {
232		files[i] = strings.TrimPrefix(f, mctx.ModuleDir()+"/")
233	}
234	return files
235}
236
237func prebuiltSdkStubs(mctx android.LoadHookContext, p *prebuiltApis) {
238	// <apiver>/<scope>/<module>.jar
239	files := globApiDirs(mctx, p, "*.jar")
240
241	sdkVersion := proptools.StringDefault(p.properties.Imports_sdk_version, "current")
242	compileDex := proptools.BoolDefault(p.properties.Imports_compile_dex, false)
243
244	for _, f := range files {
245		// create a Import module for each jar file
246		module, version, scope := parsePrebuiltPath(mctx, f)
247		createImport(mctx, module, scope, version, f, sdkVersion, compileDex)
248
249		if module == "core-for-system-modules" {
250			createSystemModules(mctx, version, scope)
251		}
252	}
253}
254
255func createSystemModules(mctx android.LoadHookContext, version, scope string) {
256	props := struct {
257		Name *string
258		Libs []string
259	}{}
260	props.Name = proptools.StringPtr(prebuiltApiModuleName(mctx, "system_modules", scope, version))
261	props.Libs = append(props.Libs, prebuiltApiModuleName(mctx, "core-for-system-modules", scope, version))
262
263	mctx.CreateModule(systemModulesImportFactory, &props)
264}
265
266func PrebuiltApiModuleName(module, scope, version string) string {
267	return module + ".api." + scope + "." + version
268}
269
270func PrebuiltApiCombinedModuleName(module, scope, version string) string {
271	return module + ".api.combined." + scope + "." + version
272}
273
274func prebuiltApiFiles(mctx android.LoadHookContext, p *prebuiltApis) {
275	// <apiver>/<scope>/api/<module>.txt
276	apiLevelFiles := globApiDirs(mctx, p, "api/*.txt")
277	if len(apiLevelFiles) == 0 {
278		mctx.ModuleErrorf("no api file found under %q", mctx.ModuleDir())
279	}
280
281	// Create modules for all (<module>, <scope, <version>) triplets,
282	allowIncremental := proptools.BoolDefault(p.properties.Allow_incremental_platform_api, false)
283	for _, f := range apiLevelFiles {
284		module, version, release, scope := parseFinalizedPrebuiltPath(mctx, f, allowIncremental)
285		if allowIncremental {
286			incrementalVersion := strconv.Itoa(version) + "." + strconv.Itoa(release)
287			createApiModule(mctx, PrebuiltApiModuleName(module, scope, incrementalVersion), f)
288		} else {
289			createApiModule(mctx, PrebuiltApiModuleName(module, scope, strconv.Itoa(version)), f)
290		}
291	}
292
293	// Figure out the latest version of each module/scope
294	type latestApiInfo struct {
295		module, scope, path string
296		version, release    int
297		isExtensionApiFile  bool
298	}
299
300	getLatest := func(files []string, isExtensionApiFile bool) map[string]latestApiInfo {
301		m := make(map[string]latestApiInfo)
302		for _, f := range files {
303			module, version, release, scope := parseFinalizedPrebuiltPath(mctx, f, allowIncremental)
304			if strings.HasSuffix(module, "incompatibilities") {
305				continue
306			}
307			key := module + "." + scope
308			info, exists := m[key]
309			if !exists || version > info.version || (version == info.version && release > info.release) {
310				m[key] = latestApiInfo{module, scope, f, version, release, isExtensionApiFile}
311			}
312		}
313		return m
314	}
315
316	latest := getLatest(apiLevelFiles, false)
317	if p.properties.Extensions_dir != nil {
318		extensionApiFiles := globExtensionDirs(mctx, p, "api/*.txt")
319		for k, v := range getLatest(extensionApiFiles, true) {
320			if _, exists := latest[k]; !exists {
321				mctx.ModuleErrorf("Module %v finalized for extension %d but never during an API level; likely error", v.module, v.version)
322			}
323			// The extension version is always at least as new as the last sdk int version (potentially identical)
324			latest[k] = v
325		}
326	}
327
328	// Sort the keys in order to make build.ninja stable
329	sortedLatestKeys := android.SortedKeys(latest)
330
331	for _, k := range sortedLatestKeys {
332		info := latest[k]
333		name := PrebuiltApiModuleName(info.module, info.scope, "latest")
334		latestExtensionVersionModuleName := PrebuiltApiModuleName(info.module, info.scope, "latest.extension_version")
335		if info.isExtensionApiFile {
336			createLatestApiModuleExtensionVersionFile(mctx, latestExtensionVersionModuleName, strconv.Itoa(info.version))
337		} else {
338			createLatestApiModuleExtensionVersionFile(mctx, latestExtensionVersionModuleName, "-1")
339		}
340		createApiModule(mctx, name, info.path)
341	}
342
343	// Create incompatibilities tracking files for all modules, if we have a "next" api.
344	incompatibilities := make(map[string]bool)
345	if nextApiDir := String(p.properties.Next_api_dir); nextApiDir != "" {
346		files := globScopeDir(mctx, nextApiDir, "api/*incompatibilities.txt")
347		for _, f := range files {
348			filename, _, scope := parsePrebuiltPath(mctx, f)
349			referencedModule := strings.TrimSuffix(filename, "-incompatibilities")
350
351			createApiModule(mctx, PrebuiltApiModuleName(referencedModule+"-incompatibilities", scope, "latest"), f)
352
353			incompatibilities[referencedModule+"."+scope] = true
354		}
355	}
356	// Create empty incompatibilities files for remaining modules
357	// If the incompatibility module has been created, create a corresponding combined module
358	for _, k := range sortedLatestKeys {
359		if _, ok := incompatibilities[k]; !ok {
360			createEmptyFile(mctx, PrebuiltApiModuleName(latest[k].module+"-incompatibilities", latest[k].scope, "latest"))
361		}
362	}
363
364	// Create combined latest api and removed api files modules.
365	// The combined modules list all api files of the api scope and its subset api scopes.
366	for _, k := range sortedLatestKeys {
367		info := latest[k]
368		name := PrebuiltApiCombinedModuleName(info.module, info.scope, "latest")
369
370		// Iterate until the currentApiScope does not extend any other api scopes
371		// i.e. is not a superset of any other api scopes
372		// the relationship between the api scopes is defined in java/sdk_library.go
373		var srcs []string
374		currentApiScope := scopeByName[info.scope]
375		for currentApiScope != nil {
376			if _, ok := latest[fmt.Sprintf("%s.%s", info.module, currentApiScope.name)]; ok {
377				srcs = append(srcs, PrebuiltApiModuleName(info.module, currentApiScope.name, "latest"))
378			}
379			currentApiScope = currentApiScope.extends
380		}
381
382		// srcs is currently listed in the order from the widest api scope to the narrowest api scopes
383		// e.g. module lib -> system -> public
384		// In order to pass the files in metalava from the narrowest api scope to the widest api scope,
385		// the list has to be reversed.
386		android.ReverseSliceInPlace(srcs)
387		createCombinedApiFilegroupModule(mctx, name, srcs)
388	}
389}
390
391func createPrebuiltApiModules(mctx android.LoadHookContext) {
392	if p, ok := mctx.Module().(*prebuiltApis); ok {
393		prebuiltApiFiles(mctx, p)
394		prebuiltSdkStubs(mctx, p)
395	}
396}
397
398// prebuilt_apis is a meta-module that generates modules for all API txt files
399// found under the directory where the Android.bp is located.
400// Specifically, an API file located at ./<ver>/<scope>/api/<module>.txt
401// generates a module named <module>-api.<scope>.<ver>.
402//
403// It also creates <module>-api.<scope>.latest for the latest <ver>.
404//
405// Similarly, it generates a java_import for all API .jar files found under the
406// directory where the Android.bp is located. Specifically, an API file located
407// at ./<ver>/<scope>/api/<module>.jar generates a java_import module named
408// <prebuilt-api-module>_<scope>_<ver>_<module>, and for SDK versions >= 30
409// a java_system_modules module named
410// <prebuilt-api-module>_public_<ver>_system_modules
411func PrebuiltApisFactory() android.Module {
412	module := &prebuiltApis{}
413	module.AddProperties(&module.properties)
414	android.InitAndroidModule(module)
415	android.AddLoadHook(module, createPrebuiltApiModules)
416	return module
417}
418