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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/*
* Copyright (C) 2011 The Android Open Source Project
*
* 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 com.android.ide.common.resources;
import com.android.SdkConstants;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.io.IAbstractFile;
import com.android.io.IAbstractFolder;
import com.android.resources.ResourceType;
import com.android.utils.ILogger;
import org.kxml2.io.KXmlParser;
import org.xmlpull.v1.XmlPullParser;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
/**
* Framework resources repository.
*
* This behaves the same as {@link ResourceRepository} except that it differentiates between
* resources that are public and non public.
* {@link #getResources(ResourceType)} and {@link #hasResourcesOfType(ResourceType)} only return
* public resources. This is typically used to display resource lists in the UI.
*
* {@link #getConfiguredResources(com.android.ide.eclipse.adt.internal.resources.configurations.FolderConfiguration)}
* returns all resources, even the non public ones so that this can be used for rendering.
*/
public class FrameworkResources extends ResourceRepository {
/**
* Map of {@link ResourceType} to list of items. It is guaranteed to contain a list for all
* possible values of ResourceType.
*/
protected final Map<ResourceType, List<ResourceItem>> mPublicResourceMap =
new EnumMap<ResourceType, List<ResourceItem>>(ResourceType.class);
public FrameworkResources() {
super(true /*isFrameworkRepository*/);
}
/**
* Returns a {@link Collection} (always non null, but can be empty) of <b>public</b>
* {@link ResourceItem} matching a given {@link ResourceType}.
*
* @param type the type of the resources to return
* @return a collection of items, possible empty.
*/
@Override
@NonNull
public List<ResourceItem> getResourceItemsOfType(@NonNull ResourceType type) {
return mPublicResourceMap.get(type);
}
/**
* Returns whether the repository has <b>public</b> resources of a given {@link ResourceType}.
* @param type the type of resource to check.
* @return true if the repository contains resources of the given type, false otherwise.
*/
@Override
public boolean hasResourcesOfType(@NonNull ResourceType type) {
return mPublicResourceMap.get(type).size() > 0;
}
@Override
@NonNull
protected ResourceItem createResourceItem(@NonNull String name) {
return new FrameworkResourceItem(name);
}
/**
* Reads the public.xml file in data/res/values/ for a given resource folder and builds up
* a map of public resources.
*
* This map is a subset of the full resource map that only contains framework resources
* that are public.
*
* @param resFolder The root folder of the resources
* @param logger a logger to report issues to
*/
public void loadPublicResources(@NonNull IAbstractFolder resFolder, @Nullable ILogger logger) {
IAbstractFolder valueFolder = resFolder.getFolder(SdkConstants.FD_RES_VALUES);
if (valueFolder.exists() == false) {
return;
}
IAbstractFile publicXmlFile = valueFolder.getFile("public.xml"); //$NON-NLS-1$
if (publicXmlFile.exists()) {
Reader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(publicXmlFile.getContents(),
"UTF-8")); //$NON-NLS-1$
KXmlParser parser = new KXmlParser();
parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false);
parser.setInput(reader);
ResourceType lastType = null;
String lastTypeName = "";
while (true) {
int event = parser.next();
if (event == XmlPullParser.START_TAG) {
// As of API 15 there are a number of "java-symbol" entries here
if (!parser.getName().equals("public")) { //$NON-NLS-1$
continue;
}
String name = null;
String typeName = null;
for (int i = 0, n = parser.getAttributeCount(); i < n; i++) {
String attribute = parser.getAttributeName(i);
if (attribute.equals("name")) { //$NON-NLS-1$
name = parser.getAttributeValue(i);
if (typeName != null) {
// Skip id attribute processing
break;
}
} else if (attribute.equals("type")) { //$NON-NLS-1$
typeName = parser.getAttributeValue(i);
}
}
if (name != null && typeName != null) {
ResourceType type = null;
if (typeName.equals(lastTypeName)) {
type = lastType;
} else {
type = ResourceType.getEnum(typeName);
lastType = type;
lastTypeName = typeName;
}
if (type != null) {
ResourceItem match = null;
Map<String, ResourceItem> map = mResourceMap.get(type);
if (map != null) {
match = map.get(name);
}
if (match != null) {
List<ResourceItem> publicList = mPublicResourceMap.get(type);
if (publicList == null) {
// Pick initial size for the list to hold the public
// resources. We could just use map.size() here,
// but they're usually much bigger; for example,
// in one platform version, there are 1500 drawables
// and 1200 strings but only 175 and 25 public ones
// respectively.
int size;
switch (type) {
case STYLE: size = 500; break;
case ATTR: size = 1000; break;
case DRAWABLE: size = 200; break;
case ID: size = 50; break;
case LAYOUT:
case COLOR:
case STRING:
case ANIM:
case INTERPOLATOR:
size = 30;
break;
default:
size = 10;
break;
}
publicList = new ArrayList<ResourceItem>(size);
mPublicResourceMap.put(type, publicList);
}
publicList.add(match);
} else {
// log that there's a public resource that doesn't actually
// exist?
}
} else {
// log that there was a reference to a typo that doesn't actually
// exist?
}
}
} else if (event == XmlPullParser.END_DOCUMENT) {
break;
}
}
} catch (Exception e) {
if (logger != null) {
logger.error(e, "Can't read and parse public attribute list");
}
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
// Nothing to be done here - we don't care if it closed or not.
}
}
}
}
// put unmodifiable list for all res type in the public resource map
// this will simplify access
for (ResourceType type : ResourceType.values()) {
List<ResourceItem> list = mPublicResourceMap.get(type);
if (list == null) {
list = Collections.emptyList();
} else {
list = Collections.unmodifiableList(list);
}
// put the new list in the map
mPublicResourceMap.put(type, list);
}
}
}
|
