1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
// Copyright 2020 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package java
import (
"android/soong/android"
)
type partitionGroup int
// Representation of partition group for checking inter-partition library dependencies.
// Between system and system_ext, there are no restrictions of dependencies,
// so we can treat these partitions as the same in terms of inter-partition dependency.
// Same policy is applied between vendor and odm partiton.
const (
partitionGroupNone partitionGroup = iota
// group for system, and system_ext partition
partitionGroupSystem
// group for vendor and odm partition
partitionGroupVendor
// product partition
partitionGroupProduct
)
func (g partitionGroup) String() string {
switch g {
case partitionGroupSystem:
return "system"
case partitionGroupVendor:
return "vendor"
case partitionGroupProduct:
return "product"
}
return ""
}
// Get partition group of java module that can be used at inter-partition dependency check.
// We currently have three groups
// (system, system_ext) => system partition group
// (vendor, odm) => vendor partition group
// (product) => product partition group
func (j *Module) partitionGroup(ctx android.EarlyModuleContext) partitionGroup {
// system and system_ext partition can be treated as the same in terms of inter-partition dependency.
if j.Platform() || j.SystemExtSpecific() {
return partitionGroupSystem
}
// vendor and odm partition can be treated as the same in terms of inter-partition dependency.
if j.SocSpecific() || j.DeviceSpecific() {
return partitionGroupVendor
}
// product partition is independent.
if j.ProductSpecific() {
return partitionGroupProduct
}
panic("Cannot determine partition type")
}
func (j *Module) allowListedInterPartitionJavaLibrary(ctx android.EarlyModuleContext) bool {
return inList(j.Name(), ctx.Config().InterPartitionJavaLibraryAllowList())
}
func (j *Module) syspropWithPublicStubs() bool {
return j.deviceProperties.SyspropPublicStub != ""
}
type javaSdkLibraryEnforceContext interface {
Name() string
allowListedInterPartitionJavaLibrary(ctx android.EarlyModuleContext) bool
partitionGroup(ctx android.EarlyModuleContext) partitionGroup
syspropWithPublicStubs() bool
}
var _ javaSdkLibraryEnforceContext = (*Module)(nil)
func (j *Module) checkPartitionsForJavaDependency(ctx android.EarlyModuleContext, propName string, dep javaSdkLibraryEnforceContext) {
if dep.allowListedInterPartitionJavaLibrary(ctx) {
return
}
if dep.syspropWithPublicStubs() {
return
}
// If product interface is not enforced, skip check between system and product partition.
// But still need to check between product and vendor partition because product interface flag
// just represents enforcement between product and system, and vendor interface enforcement
// that is enforced here by precondition is representing enforcement between vendor and other partitions.
if !ctx.Config().EnforceProductPartitionInterface() {
productToSystem := j.partitionGroup(ctx) == partitionGroupProduct && dep.partitionGroup(ctx) == partitionGroupSystem
systemToProduct := j.partitionGroup(ctx) == partitionGroupSystem && dep.partitionGroup(ctx) == partitionGroupProduct
if productToSystem || systemToProduct {
return
}
}
// If module and dependency library is inter-partition
if j.partitionGroup(ctx) != dep.partitionGroup(ctx) {
errorFormat := "dependency on java_library (%q) is not allowed across the partitions (%s -> %s), use java_sdk_library instead"
ctx.PropertyErrorf(propName, errorFormat, dep.Name(), j.partitionGroup(ctx), dep.partitionGroup(ctx))
}
}
|
