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
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
|
/*
* 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.ide.common.rendering.api.LayoutLog;
import com.android.ide.common.rendering.api.RenderResources;
import com.android.ide.common.rendering.api.ResourceValue;
import com.android.ide.common.rendering.api.StyleResourceValue;
import com.android.resources.ResourceType;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class ResourceResolver extends RenderResources {
/** The constant {@code style/} */
public final static String REFERENCE_STYLE = ResourceType.STYLE.getName() + "/";
/** The constant {@code @android:} */
public final static String PREFIX_ANDROID_RESOURCE_REF = "@android:";
/** The constant {@code @} */
public final static String PREFIX_RESOURCE_REF = "@";
/** The constant {@code ?android:} */
public final static String PREFIX_ANDROID_THEME_REF = "?android:";
/** The constant {@code ?} */
public final static String PREFIX_THEME_REF = "?";
/** The constant {@code android:} */
public final static String PREFIX_ANDROID = "android:";
/** The constant {@code @style/} */
public static final String PREFIX_STYLE = PREFIX_RESOURCE_REF + REFERENCE_STYLE;
/** The constant {@code @android:style/} */
public static final String PREFIX_ANDROID_STYLE = PREFIX_ANDROID_RESOURCE_REF
+ REFERENCE_STYLE;
private final Map<ResourceType, Map<String, ResourceValue>> mProjectResources;
private final Map<ResourceType, Map<String, ResourceValue>> mFrameworkResources;
private final Map<StyleResourceValue, StyleResourceValue> mStyleInheritanceMap =
new HashMap<StyleResourceValue, StyleResourceValue>();
private StyleResourceValue mTheme;
private FrameworkResourceIdProvider mFrameworkProvider;
private LayoutLog mLogger;
private String mThemeName;
private boolean mIsProjectTheme;
private ResourceResolver(
Map<ResourceType, Map<String, ResourceValue>> projectResources,
Map<ResourceType, Map<String, ResourceValue>> frameworkResources) {
mProjectResources = projectResources;
mFrameworkResources = frameworkResources;
}
/**
* Creates a new {@link ResourceResolver} object.
*
* @param projectResources the project resources.
* @param frameworkResources the framework resources.
* @param themeName the name of the current theme.
* @param isProjectTheme Is this a project theme?
* @return a new {@link ResourceResolver}
*/
public static ResourceResolver create(
Map<ResourceType, Map<String, ResourceValue>> projectResources,
Map<ResourceType, Map<String, ResourceValue>> frameworkResources,
String themeName, boolean isProjectTheme) {
ResourceResolver resolver = new ResourceResolver(
projectResources, frameworkResources);
resolver.computeStyleMaps(themeName, isProjectTheme);
return resolver;
}
// ---- Methods to help dealing with older LayoutLibs.
public String getThemeName() {
return mThemeName;
}
public boolean isProjectTheme() {
return mIsProjectTheme;
}
public Map<ResourceType, Map<String, ResourceValue>> getProjectResources() {
return mProjectResources;
}
public Map<ResourceType, Map<String, ResourceValue>> getFrameworkResources() {
return mFrameworkResources;
}
// ---- RenderResources Methods
@Override
public void setFrameworkResourceIdProvider(FrameworkResourceIdProvider provider) {
mFrameworkProvider = provider;
}
@Override
public void setLogger(LayoutLog logger) {
mLogger = logger;
}
@Override
public StyleResourceValue getCurrentTheme() {
return mTheme;
}
@Override
public StyleResourceValue getTheme(String name, boolean frameworkTheme) {
ResourceValue theme = null;
if (frameworkTheme) {
Map<String, ResourceValue> frameworkStyleMap = mFrameworkResources.get(
ResourceType.STYLE);
theme = frameworkStyleMap.get(name);
} else {
Map<String, ResourceValue> projectStyleMap = mProjectResources.get(ResourceType.STYLE);
theme = projectStyleMap.get(name);
}
if (theme instanceof StyleResourceValue) {
return (StyleResourceValue) theme;
}
return null;
}
@Override
public boolean themeIsParentOf(StyleResourceValue parentTheme, StyleResourceValue childTheme) {
do {
childTheme = mStyleInheritanceMap.get(childTheme);
if (childTheme == null) {
return false;
} else if (childTheme == parentTheme) {
return true;
}
} while (true);
}
@Override
public ResourceValue getFrameworkResource(ResourceType resourceType, String resourceName) {
return getResource(resourceType, resourceName, mFrameworkResources);
}
@Override
public ResourceValue getProjectResource(ResourceType resourceType, String resourceName) {
return getResource(resourceType, resourceName, mProjectResources);
}
@Override
@Deprecated
public ResourceValue findItemInStyle(StyleResourceValue style, String itemName) {
ResourceValue item = style.findValue(itemName, style.isFramework());
// if we didn't find it, we look in the parent style (if applicable)
if (item == null && mStyleInheritanceMap != null) {
StyleResourceValue parentStyle = mStyleInheritanceMap.get(style);
if (parentStyle != null) {
return findItemInStyle(parentStyle, itemName);
}
}
return item;
}
@Override
public ResourceValue findItemInStyle(StyleResourceValue style, String itemName,
boolean isFrameworkAttr) {
ResourceValue item = style.findValue(itemName, isFrameworkAttr);
// if we didn't find it, we look in the parent style (if applicable)
if (item == null && mStyleInheritanceMap != null) {
StyleResourceValue parentStyle = mStyleInheritanceMap.get(style);
if (parentStyle != null) {
return findItemInStyle(parentStyle, itemName, isFrameworkAttr);
}
}
return item;
}
@Override
public ResourceValue findResValue(String reference, boolean forceFrameworkOnly) {
if (reference == null) {
return null;
}
if (reference.startsWith(PREFIX_THEME_REF)) {
// no theme? no need to go further!
if (mTheme == null) {
return null;
}
boolean frameworkOnly = false;
// eliminate the prefix from the string
if (reference.startsWith(PREFIX_ANDROID_THEME_REF)) {
frameworkOnly = true;
reference = reference.substring(PREFIX_ANDROID_THEME_REF.length());
} else {
reference = reference.substring(PREFIX_THEME_REF.length());
}
// at this point, value can contain type/name (drawable/foo for instance).
// split it to make sure.
String[] segments = reference.split("\\/");
// we look for the referenced item name.
String referenceName = null;
if (segments.length == 2) {
// there was a resType in the reference. If it's attr, we ignore it
// else, we assert for now.
if (ResourceType.ATTR.getName().equals(segments[0])) {
referenceName = segments[1];
} else {
// At this time, no support for ?type/name where type is not "attr"
return null;
}
} else {
// it's just an item name.
referenceName = segments[0];
}
// now we look for android: in the referenceName in order to support format
// such as: ?attr/android:name
if (referenceName.startsWith(PREFIX_ANDROID)) {
frameworkOnly = true;
referenceName = referenceName.substring(PREFIX_ANDROID.length());
}
// Now look for the item in the theme, starting with the current one.
ResourceValue item = findItemInStyle(mTheme, referenceName,
forceFrameworkOnly || frameworkOnly);
if (item == null && mLogger != null) {
mLogger.warning(LayoutLog.TAG_RESOURCES_RESOLVE_THEME_ATTR,
String.format("Couldn't find theme resource %1$s for the current theme",
reference),
new ResourceValue(ResourceType.ATTR, referenceName, frameworkOnly));
}
return item;
} else if (reference.startsWith(PREFIX_RESOURCE_REF)) {
boolean frameworkOnly = false;
// check for the specific null reference value.
if (REFERENCE_NULL.equals(reference)) {
return null;
}
// Eliminate the prefix from the string.
if (reference.startsWith(PREFIX_ANDROID_RESOURCE_REF)) {
frameworkOnly = true;
reference = reference.substring(
PREFIX_ANDROID_RESOURCE_REF.length());
} else {
reference = reference.substring(PREFIX_RESOURCE_REF.length());
}
// at this point, value contains type/[android:]name (drawable/foo for instance)
String[] segments = reference.split("\\/");
// now we look for android: in the resource name in order to support format
// such as: @drawable/android:name
if (segments[1].startsWith(PREFIX_ANDROID)) {
frameworkOnly = true;
segments[1] = segments[1].substring(PREFIX_ANDROID.length());
}
ResourceType type = ResourceType.getEnum(segments[0]);
// unknown type?
if (type == null) {
return null;
}
return findResValue(type, segments[1],
forceFrameworkOnly ? true :frameworkOnly);
}
// Looks like the value didn't reference anything. Return null.
return null;
}
@Override
public ResourceValue resolveValue(ResourceType type, String name, String value,
boolean isFrameworkValue) {
if (value == null) {
return null;
}
// get the ResourceValue referenced by this value
ResourceValue resValue = findResValue(value, isFrameworkValue);
// if resValue is null, but value is not null, this means it was not a reference.
// we return the name/value wrapper in a ResourceValue. the isFramework flag doesn't
// matter.
if (resValue == null) {
return new ResourceValue(type, name, value, isFrameworkValue);
}
// we resolved a first reference, but we need to make sure this isn't a reference also.
return resolveResValue(resValue);
}
@Override
public ResourceValue resolveResValue(ResourceValue resValue) {
if (resValue == null) {
return null;
}
// if the resource value is null, we simply return it.
String value = resValue.getValue();
if (value == null) {
return resValue;
}
// else attempt to find another ResourceValue referenced by this one.
ResourceValue resolvedResValue = findResValue(value, resValue.isFramework());
// if the value did not reference anything, then we simply return the input value
if (resolvedResValue == null) {
return resValue;
}
// detect potential loop due to mishandled namespace in attributes
if (resValue == resolvedResValue) {
if (mLogger != null) {
mLogger.error(LayoutLog.TAG_BROKEN,
String.format("Potential stackoverflow trying to resolve '%s'. Render may not be accurate.", value),
null);
}
return resValue;
}
// otherwise, we attempt to resolve this new value as well
return resolveResValue(resolvedResValue);
}
// ---- Private helper methods.
/**
* Searches for, and returns a {@link ResourceValue} by its name, and type.
* @param resType the type of the resource
* @param resName the name of the resource
* @param frameworkOnly if <code>true</code>, the method does not search in the
* project resources
*/
private ResourceValue findResValue(ResourceType resType, String resName,
boolean frameworkOnly) {
// map of ResouceValue for the given type
Map<String, ResourceValue> typeMap;
// if allowed, search in the project resources first.
if (frameworkOnly == false) {
typeMap = mProjectResources.get(resType);
ResourceValue item = typeMap.get(resName);
if (item != null) {
return item;
}
}
// now search in the framework resources.
typeMap = mFrameworkResources.get(resType);
ResourceValue item = typeMap.get(resName);
if (item != null) {
return item;
}
// if it was not found and the type is an id, it is possible that the ID was
// generated dynamically when compiling the framework resources.
// Look for it in the R map.
if (mFrameworkProvider != null && resType == ResourceType.ID) {
if (mFrameworkProvider.getId(resType, resName) != null) {
return new ResourceValue(resType, resName, true);
}
}
// didn't find the resource anywhere.
if (mLogger != null) {
mLogger.warning(LayoutLog.TAG_RESOURCES_RESOLVE,
"Couldn't resolve resource @" +
(frameworkOnly ? "android:" : "") + resType + "/" + resName,
new ResourceValue(resType, resName, frameworkOnly));
}
return null;
}
private ResourceValue getResource(ResourceType resourceType, String resourceName,
Map<ResourceType, Map<String, ResourceValue>> resourceRepository) {
Map<String, ResourceValue> typeMap = resourceRepository.get(resourceType);
if (typeMap != null) {
ResourceValue item = typeMap.get(resourceName);
if (item != null) {
item = resolveResValue(item);
return item;
}
}
// didn't find the resource anywhere.
return null;
}
/**
* Compute style information from the given list of style for the project and framework.
* @param themeName the name of the current theme.
* @param isProjectTheme Is this a project theme?
*/
private void computeStyleMaps(String themeName, boolean isProjectTheme) {
mThemeName = themeName;
mIsProjectTheme = isProjectTheme;
Map<String, ResourceValue> projectStyleMap = mProjectResources.get(ResourceType.STYLE);
Map<String, ResourceValue> frameworkStyleMap = mFrameworkResources.get(ResourceType.STYLE);
// first, get the theme
ResourceValue theme = null;
// project theme names have been prepended with a *
if (isProjectTheme) {
theme = projectStyleMap.get(themeName);
} else {
theme = frameworkStyleMap.get(themeName);
}
if (theme instanceof StyleResourceValue) {
// compute the inheritance map for both the project and framework styles
computeStyleInheritance(projectStyleMap.values(), projectStyleMap,
frameworkStyleMap);
// Compute the style inheritance for the framework styles/themes.
// Since, for those, the style parent values do not contain 'android:'
// we want to force looking in the framework style only to avoid using
// similarly named styles from the project.
// To do this, we pass null in lieu of the project style map.
computeStyleInheritance(frameworkStyleMap.values(), null /*inProjectStyleMap */,
frameworkStyleMap);
mTheme = (StyleResourceValue) theme;
}
}
/**
* Compute the parent style for all the styles in a given list.
* @param styles the styles for which we compute the parent.
* @param inProjectStyleMap the map of project styles.
* @param inFrameworkStyleMap the map of framework styles.
* @param outInheritanceMap the map of style inheritance. This is filled by the method.
*/
private void computeStyleInheritance(Collection<ResourceValue> styles,
Map<String, ResourceValue> inProjectStyleMap,
Map<String, ResourceValue> inFrameworkStyleMap) {
for (ResourceValue value : styles) {
if (value instanceof StyleResourceValue) {
StyleResourceValue style = (StyleResourceValue)value;
StyleResourceValue parentStyle = null;
// first look for a specified parent.
String parentName = style.getParentStyle();
// no specified parent? try to infer it from the name of the style.
if (parentName == null) {
parentName = getParentName(value.getName());
}
if (parentName != null) {
parentStyle = getStyle(parentName, inProjectStyleMap, inFrameworkStyleMap);
if (parentStyle != null) {
mStyleInheritanceMap.put(style, parentStyle);
}
}
}
}
}
/**
* Computes the name of the parent style, or <code>null</code> if the style is a root style.
*/
private String getParentName(String styleName) {
int index = styleName.lastIndexOf('.');
if (index != -1) {
return styleName.substring(0, index);
}
return null;
}
/**
* Searches for and returns the {@link StyleResourceValue} from a given name.
* <p/>The format of the name can be:
* <ul>
* <li>[android:]<name></li>
* <li>[android:]style/<name></li>
* <li>@[android:]style/<name></li>
* </ul>
* @param parentName the name of the style.
* @param inProjectStyleMap the project style map. Can be <code>null</code>
* @param inFrameworkStyleMap the framework style map.
* @return The matching {@link StyleResourceValue} object or <code>null</code> if not found.
*/
private StyleResourceValue getStyle(String parentName,
Map<String, ResourceValue> inProjectStyleMap,
Map<String, ResourceValue> inFrameworkStyleMap) {
boolean frameworkOnly = false;
String name = parentName;
// remove the useless @ if it's there
if (name.startsWith(PREFIX_RESOURCE_REF)) {
name = name.substring(PREFIX_RESOURCE_REF.length());
}
// check for framework identifier.
if (name.startsWith(PREFIX_ANDROID)) {
frameworkOnly = true;
name = name.substring(PREFIX_ANDROID.length());
}
// at this point we could have the format <type>/<name>. we want only the name as long as
// the type is style.
if (name.startsWith(REFERENCE_STYLE)) {
name = name.substring(REFERENCE_STYLE.length());
} else if (name.indexOf('/') != -1) {
return null;
}
ResourceValue parent = null;
// if allowed, search in the project resources.
if (frameworkOnly == false && inProjectStyleMap != null) {
parent = inProjectStyleMap.get(name);
}
// if not found, then look in the framework resources.
if (parent == null) {
parent = inFrameworkStyleMap.get(name);
}
// make sure the result is the proper class type and return it.
if (parent instanceof StyleResourceValue) {
return (StyleResourceValue)parent;
}
if (mLogger != null) {
mLogger.error(LayoutLog.TAG_RESOURCES_RESOLVE,
String.format("Unable to resolve parent style name: %s", parentName),
null /*data*/);
}
return null;
}
}
|