mirror of
https://github.com/revanced/ARSCLib.git
synced 2025-05-01 14:44:27 +02:00
1432 lines
46 KiB
Java
Executable File
1432 lines
46 KiB
Java
Executable File
/*
|
|
* Copyright (C) 2022 github.com/REAndroid
|
|
*
|
|
* 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.reandroid.lib.arsc.value;
|
|
|
|
import java.util.*;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
|
|
public class ResConfigHelper {
|
|
public static ResConfig fromQualifiers(String qualifiers){
|
|
ResConfig result=new ResConfig();
|
|
result.setConfigSize(ResConfig.SIZE_64);
|
|
parseQualifiers(result, qualifiers);
|
|
result.refresh();
|
|
return result;
|
|
}
|
|
static String toQualifier(ResConfig resConfig){
|
|
StringBuilder builder=new StringBuilder();
|
|
builder.append(decodeLanguageAndCountry(resConfig));
|
|
builder.append(decodeOrientation(resConfig));
|
|
builder.append(decodeScreenLayout(resConfig));
|
|
builder.append(decodeScreenLayout2(resConfig));
|
|
builder.append(decodeScreenSize(resConfig));
|
|
builder.append(decodeDensity(resConfig));
|
|
builder.append(decodeScreenHeightDp(resConfig));
|
|
builder.append(decodeSmallestScreenWidthDp(resConfig));
|
|
builder.append(decodeScreenWidthDp(resConfig));
|
|
builder.append(decodeNavigation(resConfig));
|
|
builder.append(decodeUiMode(resConfig));
|
|
builder.append(decodeTouchscreen(resConfig));
|
|
builder.append(decodeKeyboard(resConfig));
|
|
builder.append(decodeInputFlags(resConfig));
|
|
builder.append(decodeMccMnc(resConfig));
|
|
builder.append(decodeSdkVersion(resConfig));
|
|
return sortQualifiers(builder.toString());
|
|
}
|
|
|
|
static void parseQualifiers(ResConfig resConfig, String name){
|
|
if(resConfig == null || name==null){
|
|
return;
|
|
}
|
|
String[] split=name.split("-");
|
|
if(isNull(split)){
|
|
return;
|
|
}
|
|
encode(resConfig, split);
|
|
}
|
|
public static String sortQualifiers(String qualifiers){
|
|
if(!qualifiers.startsWith("-")){
|
|
return qualifiers;
|
|
}
|
|
String[] split=qualifiers.split("-");
|
|
if(isNull(split)){
|
|
return qualifiers;
|
|
}
|
|
List<String> qList=new ArrayList<>();
|
|
for(int i=0;i<split.length;i++){
|
|
String q=split[i];
|
|
if(q!=null && !qList.contains(q)){
|
|
qList.add(q);
|
|
}
|
|
}
|
|
Comparator<String> cmp=new Comparator<String>() {
|
|
@Override
|
|
public int compare(String s1, String s2) {
|
|
return s1.compareTo(s2);
|
|
}
|
|
};
|
|
qList.sort(cmp);
|
|
StringBuilder builder=new StringBuilder();
|
|
for(String q:qList){
|
|
builder.append('-');
|
|
builder.append(q);
|
|
}
|
|
return builder.toString();
|
|
}
|
|
private static void encode(ResConfig resConfig, String[] split){
|
|
encodeDensity(resConfig, split);
|
|
encodeScreenHeightDp(resConfig, split);
|
|
encodeScreenWidthDp(resConfig, split);
|
|
encodeSmallestScreenWidthDp(resConfig, split);
|
|
encodeNavigation(resConfig, split);
|
|
encodeInputFlags(resConfig, split);
|
|
encodeSdkVersion(resConfig, split);
|
|
encodeKeyboard(resConfig, split);
|
|
encodeTouchscreen(resConfig, split);
|
|
encodeUiMode(resConfig, split);
|
|
encodeOrientation(resConfig, split);
|
|
encodeScreenLayout(resConfig, split);
|
|
encodeScreenLayout2(resConfig, split);
|
|
encodeMcc(resConfig, split);
|
|
encodeMnc(resConfig, split);
|
|
encodeScreenSize(resConfig, split);
|
|
encodeLanguageAndCountry(resConfig, split);
|
|
}
|
|
|
|
private static void encodeLanguageAndCountry(ResConfig resConfig, String[] split){
|
|
if(split==null){
|
|
return;
|
|
}
|
|
String lang=null;
|
|
String country=null;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
if(lang==null){
|
|
if(isLanguageName(s)){
|
|
lang=s;
|
|
split[i]=null;
|
|
}else if(isCountryName(s)){
|
|
country=s;
|
|
split[i]=null;
|
|
}
|
|
continue;
|
|
}
|
|
if(country!=null){
|
|
break;
|
|
}
|
|
if(isCountryName(s)){
|
|
country=s;
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(lang!=null){
|
|
char[] chs=lang.toCharArray();
|
|
resConfig.setLanguage(chs);
|
|
}
|
|
if(country==null){
|
|
return;
|
|
}
|
|
if(country.length()>2 && country.startsWith("r")){
|
|
country=country.substring(1);
|
|
}
|
|
char[] chs=country.toCharArray();
|
|
resConfig.setRegion(chs);
|
|
}
|
|
public static String decodeLanguage(char[] language){
|
|
StringBuilder builder=new StringBuilder();
|
|
if(language[0]!=0){
|
|
builder.append(language[0]).append(language[1]);
|
|
}
|
|
if(builder.length()==0){
|
|
return null;
|
|
}
|
|
return builder.toString();
|
|
}
|
|
public static String decodeRegion(char[] region){
|
|
StringBuilder builder=new StringBuilder();
|
|
if(region[0]!=0){
|
|
builder.append(region[0]).append(region[1]);
|
|
}
|
|
if(builder.length()==0){
|
|
return null;
|
|
}
|
|
return builder.toString();
|
|
}
|
|
public static String decodeLocale(ResConfig resConfig){
|
|
char[] region=resConfig.getRegionChars();
|
|
char[] language=resConfig.getLanguageChars();
|
|
StringBuilder builder=new StringBuilder();
|
|
if(language[0]!=0){
|
|
builder.append(language[0]).append(language[1]);
|
|
}
|
|
if(region[0]!=0){
|
|
if(language[0]!=0){
|
|
builder.append('-');
|
|
}
|
|
builder.append(region[0]).append(region[1]);
|
|
}
|
|
if(builder.length()==0){
|
|
return null;
|
|
}
|
|
return builder.toString();
|
|
}
|
|
private static String decodeLanguageAndCountry(ResConfig resConfig) {
|
|
StringBuilder builder = new StringBuilder();
|
|
char[] localeVariant=resConfig.getLocaleVariant();
|
|
char[] localeScript=resConfig.getLocaleScript();
|
|
char[] region=resConfig.getRegionChars();
|
|
char[] language=resConfig.getLanguageChars();
|
|
if (localeVariant == null && localeScript == null && (region[0] != '\00' || language[0] != '\00') &&
|
|
region.length != 3) {
|
|
builder.append("-").append(language);
|
|
if (region[0] != '\00') {
|
|
builder.append("-r").append(region);
|
|
}
|
|
} else {
|
|
if (language[0] == '\00' && region[0] == '\00') {
|
|
return builder.toString();
|
|
}
|
|
builder.append("-b+");
|
|
if (language[0] != '\00') {
|
|
builder.append(language);
|
|
}
|
|
if (localeScript != null && localeScript.length == 4) {
|
|
builder.append("+").append(localeScript);
|
|
}
|
|
if ((region.length == 2 || region.length == 3) && region[0] != '\00') {
|
|
builder.append("+").append(region);
|
|
}
|
|
if (localeVariant != null && localeVariant.length >= 5) {
|
|
builder.append("+").append(toUpper(localeVariant));
|
|
}
|
|
}
|
|
return builder.toString();
|
|
}
|
|
private static void encodeNavigation(ResConfig resConfig, String[] split){
|
|
byte navigation=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
switch (s) {
|
|
case "nonav":
|
|
navigation = NAVIGATION_NONAV;
|
|
break;
|
|
case "dpad":
|
|
navigation = NAVIGATION_DPAD;
|
|
break;
|
|
case "trackball":
|
|
navigation = NAVIGATION_TRACKBALL;
|
|
break;
|
|
case "wheel":
|
|
navigation = NAVIGATION_WHEEL;
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setNavigation(navigation);
|
|
}
|
|
private static String decodeNavigation(ResConfig resConfig){
|
|
StringBuilder ret=new StringBuilder();
|
|
switch (resConfig.getNavigationByte()) {
|
|
case NAVIGATION_NONAV:
|
|
ret.append("-nonav");
|
|
break;
|
|
case NAVIGATION_DPAD:
|
|
ret.append("-dpad");
|
|
break;
|
|
case NAVIGATION_TRACKBALL:
|
|
ret.append("-trackball");
|
|
break;
|
|
case NAVIGATION_WHEEL:
|
|
ret.append("-wheel");
|
|
break;
|
|
}
|
|
return ret.toString();
|
|
}
|
|
private static void encodeInputFlags(ResConfig resConfig, String[] split){
|
|
int inputFlags=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
int val;
|
|
switch (s) {
|
|
case "keysexposed":
|
|
val = (KEYSHIDDEN_NO);
|
|
break;
|
|
case "keyshidden":
|
|
val = (KEYSHIDDEN_YES);
|
|
break;
|
|
case "keyssoft":
|
|
val = (KEYSHIDDEN_SOFT);
|
|
break;
|
|
case "navexposed":
|
|
val = (NAVHIDDEN_NO);
|
|
break;
|
|
case "navhidden":
|
|
val = (NAVHIDDEN_YES);
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
inputFlags=(inputFlags | val);
|
|
split[i]=null;
|
|
}
|
|
resConfig.setInputFlags((byte)inputFlags);
|
|
}
|
|
public static byte encodeInputFlags(String inputFlags){
|
|
if(inputFlags==null){
|
|
return 0;
|
|
}
|
|
String[] split=inputFlags.split("-");
|
|
int result=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
int val;
|
|
switch (s) {
|
|
case "keysexposed":
|
|
val = (KEYSHIDDEN_NO);
|
|
break;
|
|
case "keyshidden":
|
|
val = (KEYSHIDDEN_YES);
|
|
break;
|
|
case "keyssoft":
|
|
val = (KEYSHIDDEN_SOFT);
|
|
break;
|
|
case "navexposed":
|
|
val = (NAVHIDDEN_NO);
|
|
break;
|
|
case "navhidden":
|
|
val = (NAVHIDDEN_YES);
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
result=(result | val);
|
|
split[i]=null;
|
|
}
|
|
return (byte)result;
|
|
}
|
|
private static String decodeInputFlags(ResConfig resConfig){
|
|
StringBuilder ret=new StringBuilder();
|
|
int inputFlags=resConfig.getInputFlagsValue();
|
|
switch (inputFlags & MASK_KEYSHIDDEN) {
|
|
case KEYSHIDDEN_NO:
|
|
ret.append("-keysexposed");
|
|
break;
|
|
case KEYSHIDDEN_YES:
|
|
ret.append("-keyshidden");
|
|
break;
|
|
case KEYSHIDDEN_SOFT:
|
|
ret.append("-keyssoft");
|
|
break;
|
|
}
|
|
switch (inputFlags & MASK_NAVHIDDEN) {
|
|
case NAVHIDDEN_NO:
|
|
ret.append("-navexposed");
|
|
break;
|
|
case NAVHIDDEN_YES:
|
|
ret.append("-navhidden");
|
|
break;
|
|
}
|
|
return ret.toString();
|
|
}
|
|
public static String decodeInputFlags(byte inputFlags){
|
|
StringBuilder builder=new StringBuilder();
|
|
switch (inputFlags & MASK_KEYSHIDDEN) {
|
|
case KEYSHIDDEN_NO:
|
|
builder.append("-keysexposed");
|
|
break;
|
|
case KEYSHIDDEN_YES:
|
|
builder.append("-keyshidden");
|
|
break;
|
|
case KEYSHIDDEN_SOFT:
|
|
builder.append("-keyssoft");
|
|
break;
|
|
}
|
|
switch (inputFlags & MASK_NAVHIDDEN) {
|
|
case NAVHIDDEN_NO:
|
|
builder.append("-navexposed");
|
|
break;
|
|
case NAVHIDDEN_YES:
|
|
builder.append("-navhidden");
|
|
break;
|
|
}
|
|
if(builder.length()==0){
|
|
return null;
|
|
}
|
|
return builder.toString();
|
|
}
|
|
private static void encodeKeyboard(ResConfig resConfig, String[] split){
|
|
byte keyboard=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
switch (s) {
|
|
case "nokeys":
|
|
keyboard = KEYBOARD_NOKEYS;
|
|
break;
|
|
case "qwerty":
|
|
keyboard = KEYBOARD_QWERTY;
|
|
break;
|
|
case "12key":
|
|
keyboard = KEYBOARD_12KEY;
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setKeyboard(keyboard);
|
|
}
|
|
private static String decodeKeyboard(ResConfig resConfig){
|
|
StringBuilder ret=new StringBuilder();
|
|
switch (resConfig.getKeyboardByte()) {
|
|
case KEYBOARD_NOKEYS:
|
|
ret.append("-nokeys");
|
|
break;
|
|
case KEYBOARD_QWERTY:
|
|
ret.append("-qwerty");
|
|
break;
|
|
case KEYBOARD_12KEY:
|
|
ret.append("-12key");
|
|
break;
|
|
}
|
|
return ret.toString();
|
|
}
|
|
/*
|
|
* Encodes density to value
|
|
* densityName is full name like: mdpi, xxxdpi, 580dpi ... */
|
|
public static short encodeDensity(String densityName){
|
|
short density=0;
|
|
if(densityName==null){
|
|
return density;
|
|
}
|
|
Matcher matcher=PATTERN_DENSITY.matcher(densityName);
|
|
if(!matcher.find()){
|
|
return density;
|
|
}
|
|
return encodeDensityName(matcher.group(1));
|
|
}
|
|
private static short encodeDensityName(String name){
|
|
if("l".equals(name)){
|
|
return DENSITY_LOW;
|
|
}else if("m".equals(name)){
|
|
return DENSITY_MEDIUM;
|
|
}else if("h".equals(name)){
|
|
return DENSITY_HIGH;
|
|
}else if("tv".equals(name)){
|
|
return DENSITY_TV;
|
|
}else if("xh".equals(name)){
|
|
return DENSITY_XHIGH;
|
|
}else if("xxh".equals(name)){
|
|
return DENSITY_XXHIGH;
|
|
}else if("xxxh".equals(name)){
|
|
return DENSITY_XXXHIGH;
|
|
}else if("any".equals(name)){
|
|
return DENSITY_ANY;
|
|
}else if("no".equals(name)){
|
|
return DENSITY_NONE;
|
|
}else if(isDecimal(name)){
|
|
return (short) Integer.parseInt(name);
|
|
}
|
|
return 0;
|
|
}
|
|
private static void encodeDensity(ResConfig resConfig, String[] split){
|
|
int density=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
Matcher matcher=PATTERN_DENSITY.matcher(s);
|
|
if(!matcher.find()){
|
|
continue;
|
|
}
|
|
density=encodeDensityName(matcher.group(1));
|
|
if(density==0){
|
|
continue;
|
|
}
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setDensity((short) density);
|
|
}
|
|
private static String decodeDensity(ResConfig resConfig){
|
|
StringBuilder ret=new StringBuilder();
|
|
int density=resConfig.getDensityValue();
|
|
switch (density) {
|
|
case DENSITY_DEFAULT:
|
|
break;
|
|
case DENSITY_LOW:
|
|
ret.append("-ldpi");
|
|
break;
|
|
case DENSITY_MEDIUM:
|
|
ret.append("-mdpi");
|
|
break;
|
|
case DENSITY_HIGH:
|
|
ret.append("-hdpi");
|
|
break;
|
|
case DENSITY_TV:
|
|
ret.append("-tvdpi");
|
|
break;
|
|
case DENSITY_XHIGH:
|
|
ret.append("-xhdpi");
|
|
break;
|
|
case DENSITY_XXHIGH:
|
|
ret.append("-xxhdpi");
|
|
break;
|
|
case DENSITY_XXXHIGH:
|
|
ret.append("-xxxhdpi");
|
|
break;
|
|
case DENSITY_ANY:
|
|
ret.append("-anydpi");
|
|
break;
|
|
case DENSITY_NONE:
|
|
ret.append("-nodpi");
|
|
break;
|
|
default:
|
|
ret.append('-').append(density).append("dpi");
|
|
}
|
|
return ret.toString();
|
|
}
|
|
public static String decodeDensity(short density){
|
|
switch (density) {
|
|
case DENSITY_DEFAULT:
|
|
return null;
|
|
case DENSITY_LOW:
|
|
return "ldpi";
|
|
case DENSITY_MEDIUM:
|
|
return "mdpi";
|
|
case DENSITY_HIGH:
|
|
return "hdpi";
|
|
case DENSITY_TV:
|
|
return "tvdpi";
|
|
case DENSITY_XHIGH:
|
|
return "xhdpi";
|
|
case DENSITY_XXHIGH:
|
|
return "xxhdpi";
|
|
case DENSITY_XXXHIGH:
|
|
return "xxxhdpi";
|
|
case DENSITY_ANY:
|
|
return "anydpi";
|
|
case DENSITY_NONE:
|
|
return "nodpi";
|
|
default:
|
|
return density+"dpi";
|
|
}
|
|
}
|
|
private static void encodeTouchscreen(ResConfig resConfig, String[] split){
|
|
byte touchscreen=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
switch (s) {
|
|
case "notouch":
|
|
touchscreen = TOUCHSCREEN_NOTOUCH;
|
|
break;
|
|
case "stylus":
|
|
touchscreen = TOUCHSCREEN_STYLUS;
|
|
break;
|
|
case "finger":
|
|
touchscreen = TOUCHSCREEN_FINGER;
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setTouchscreen(touchscreen);
|
|
}
|
|
private static String decodeTouchscreen(ResConfig resConfig){
|
|
StringBuilder ret=new StringBuilder();
|
|
byte touchscreen=resConfig.getTouchscreenByte();
|
|
switch (touchscreen) {
|
|
case TOUCHSCREEN_NOTOUCH:
|
|
ret.append("-notouch");
|
|
break;
|
|
case TOUCHSCREEN_STYLUS:
|
|
ret.append("-stylus");
|
|
break;
|
|
case TOUCHSCREEN_FINGER:
|
|
ret.append("-finger");
|
|
break;
|
|
}
|
|
return ret.toString();
|
|
}
|
|
private static void encodeUiMode(ResConfig resConfig, String[] split){
|
|
int uiMode=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
int val;
|
|
switch (s) {
|
|
case "car":
|
|
val = (UI_MODE_TYPE_CAR);
|
|
break;
|
|
case "desk":
|
|
val = (UI_MODE_TYPE_DESK);
|
|
break;
|
|
case "television":
|
|
val = (UI_MODE_TYPE_TELEVISION);
|
|
break;
|
|
case "smallui":
|
|
val = (UI_MODE_TYPE_SMALLUI);
|
|
break;
|
|
case "mediumui":
|
|
val = (UI_MODE_TYPE_MEDIUMUI);
|
|
break;
|
|
case "largeui":
|
|
val = (UI_MODE_TYPE_LARGEUI);
|
|
break;
|
|
case "godzillaui":
|
|
val = (UI_MODE_TYPE_GODZILLAUI);
|
|
break;
|
|
case "hugeui":
|
|
val = (UI_MODE_TYPE_HUGEUI);
|
|
break;
|
|
case "appliance":
|
|
val = (UI_MODE_TYPE_APPLIANCE);
|
|
break;
|
|
case "watch":
|
|
val = (UI_MODE_TYPE_WATCH);
|
|
break;
|
|
case "vrheadset":
|
|
val = (UI_MODE_TYPE_VR_HEADSET);
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
uiMode=(uiMode | val);
|
|
split[i]=null;
|
|
}
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
int val;
|
|
if("night".equals(s)){
|
|
val = (UI_MODE_NIGHT_YES);
|
|
}else if("notnight".equals(s)){
|
|
val = (UI_MODE_NIGHT_NO);
|
|
}else {
|
|
continue;
|
|
}
|
|
uiMode=(uiMode | val);
|
|
split[i]=null;
|
|
}
|
|
resConfig.setUiMode((byte)uiMode);
|
|
}
|
|
public static byte encodeUiMode(String uiMode){
|
|
if(uiMode==null){
|
|
return 0;
|
|
}
|
|
String[] split=uiMode.split("-");
|
|
int result=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
int val;
|
|
switch (s) {
|
|
case "car":
|
|
val = (UI_MODE_TYPE_CAR);
|
|
break;
|
|
case "desk":
|
|
val = (UI_MODE_TYPE_DESK);
|
|
break;
|
|
case "television":
|
|
val = (UI_MODE_TYPE_TELEVISION);
|
|
break;
|
|
case "smallui":
|
|
val = (UI_MODE_TYPE_SMALLUI);
|
|
break;
|
|
case "mediumui":
|
|
val = (UI_MODE_TYPE_MEDIUMUI);
|
|
break;
|
|
case "largeui":
|
|
val = (UI_MODE_TYPE_LARGEUI);
|
|
break;
|
|
case "godzillaui":
|
|
val = (UI_MODE_TYPE_GODZILLAUI);
|
|
break;
|
|
case "hugeui":
|
|
val = (UI_MODE_TYPE_HUGEUI);
|
|
break;
|
|
case "appliance":
|
|
val = (UI_MODE_TYPE_APPLIANCE);
|
|
break;
|
|
case "watch":
|
|
val = (UI_MODE_TYPE_WATCH);
|
|
break;
|
|
case "vrheadset":
|
|
val = (UI_MODE_TYPE_VR_HEADSET);
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
result=(result | val);
|
|
split[i]=null;
|
|
}
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
int val;
|
|
if("night".equals(s)){
|
|
val = (UI_MODE_NIGHT_YES);
|
|
}else if("notnight".equals(s)){
|
|
val = (UI_MODE_NIGHT_NO);
|
|
}else {
|
|
continue;
|
|
}
|
|
result=(result | val);
|
|
split[i]=null;
|
|
}
|
|
return (byte)result;
|
|
}
|
|
public static String decodeUiMode(byte uiMode){
|
|
StringBuilder ret=new StringBuilder();
|
|
switch (uiMode & MASK_UI_MODE_TYPE) {
|
|
case UI_MODE_TYPE_CAR:
|
|
ret.append("-car");
|
|
break;
|
|
case UI_MODE_TYPE_DESK:
|
|
ret.append("-desk");
|
|
break;
|
|
case UI_MODE_TYPE_TELEVISION:
|
|
ret.append("-television");
|
|
break;
|
|
case UI_MODE_TYPE_SMALLUI:
|
|
ret.append("-smallui");
|
|
break;
|
|
case UI_MODE_TYPE_MEDIUMUI:
|
|
ret.append("-mediumui");
|
|
break;
|
|
case UI_MODE_TYPE_LARGEUI:
|
|
ret.append("-largeui");
|
|
break;
|
|
case UI_MODE_TYPE_GODZILLAUI:
|
|
ret.append("-godzillaui");
|
|
break;
|
|
case UI_MODE_TYPE_HUGEUI:
|
|
ret.append("-hugeui");
|
|
break;
|
|
case UI_MODE_TYPE_APPLIANCE:
|
|
ret.append("-appliance");
|
|
break;
|
|
case UI_MODE_TYPE_WATCH:
|
|
ret.append("-watch");
|
|
break;
|
|
case UI_MODE_TYPE_VR_HEADSET:
|
|
ret.append("-vrheadset");
|
|
break;
|
|
}
|
|
switch (uiMode & MASK_UI_MODE_NIGHT) {
|
|
case UI_MODE_NIGHT_YES:
|
|
ret.append("-night");
|
|
break;
|
|
case UI_MODE_NIGHT_NO:
|
|
ret.append("-notnight");
|
|
break;
|
|
}
|
|
if(ret.length()==0){
|
|
return null;
|
|
}
|
|
return ret.toString();
|
|
}
|
|
private static String decodeUiMode(ResConfig resConfig){
|
|
StringBuilder ret=new StringBuilder();
|
|
byte uiMode=resConfig.getUiModeValue();
|
|
switch (uiMode & MASK_UI_MODE_TYPE) {
|
|
case UI_MODE_TYPE_CAR:
|
|
ret.append("-car");
|
|
break;
|
|
case UI_MODE_TYPE_DESK:
|
|
ret.append("-desk");
|
|
break;
|
|
case UI_MODE_TYPE_TELEVISION:
|
|
ret.append("-television");
|
|
break;
|
|
case UI_MODE_TYPE_SMALLUI:
|
|
ret.append("-smallui");
|
|
break;
|
|
case UI_MODE_TYPE_MEDIUMUI:
|
|
ret.append("-mediumui");
|
|
break;
|
|
case UI_MODE_TYPE_LARGEUI:
|
|
ret.append("-largeui");
|
|
break;
|
|
case UI_MODE_TYPE_GODZILLAUI:
|
|
ret.append("-godzillaui");
|
|
break;
|
|
case UI_MODE_TYPE_HUGEUI:
|
|
ret.append("-hugeui");
|
|
break;
|
|
case UI_MODE_TYPE_APPLIANCE:
|
|
ret.append("-appliance");
|
|
break;
|
|
case UI_MODE_TYPE_WATCH:
|
|
ret.append("-watch");
|
|
break;
|
|
case UI_MODE_TYPE_VR_HEADSET:
|
|
ret.append("-vrheadset");
|
|
break;
|
|
}
|
|
switch (uiMode & MASK_UI_MODE_NIGHT) {
|
|
case UI_MODE_NIGHT_YES:
|
|
ret.append("-night");
|
|
break;
|
|
case UI_MODE_NIGHT_NO:
|
|
ret.append("-notnight");
|
|
break;
|
|
}
|
|
return ret.toString();
|
|
}
|
|
private static void encodeOrientation(ResConfig resConfig, String[] split){
|
|
byte orientationByte=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
ResConfig.Orientation orientation= ResConfig.Orientation.fromName(s);
|
|
if(orientation==null){
|
|
continue;
|
|
}
|
|
orientationByte=orientation.getByteValue();
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setOrientation(orientationByte);
|
|
}
|
|
private static String decodeOrientation(ResConfig resConfig){
|
|
ResConfig.Orientation orientation=resConfig.getOrientation();
|
|
if(orientation==null){
|
|
return null;
|
|
}
|
|
return "-"+orientation.toString();
|
|
}
|
|
private static void encodeScreenLayout(ResConfig resConfig, String[] split){
|
|
int screenLayout=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
int val;
|
|
switch (s) {
|
|
case "ldrtl":
|
|
val = (SCREENLAYOUT_LAYOUTDIR_RTL);
|
|
break;
|
|
case "ldltr":
|
|
val = (SCREENLAYOUT_LAYOUTDIR_LTR);
|
|
break;
|
|
case "small":
|
|
val = (SCREENSIZE_SMALL);
|
|
break;
|
|
case "normal":
|
|
val = (SCREENSIZE_NORMAL);
|
|
break;
|
|
case "large":
|
|
val = (SCREENSIZE_LARGE);
|
|
break;
|
|
case "xlarge":
|
|
val = (SCREENSIZE_XLARGE);
|
|
break;
|
|
case "long":
|
|
val = (SCREENLONG_YES);
|
|
break;
|
|
case "notlong":
|
|
val = (SCREENLONG_NO);
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
screenLayout = (screenLayout | val);
|
|
split[i]=null;
|
|
}
|
|
resConfig.setScreenLayout((byte) screenLayout);
|
|
}
|
|
public static byte encodeScreenLayout(String screenLayout){
|
|
if(screenLayout==null){
|
|
return 0;
|
|
}
|
|
String[] split=screenLayout.split("-");
|
|
int result=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
int val;
|
|
switch (s) {
|
|
case "ldrtl":
|
|
val = (SCREENLAYOUT_LAYOUTDIR_RTL);
|
|
break;
|
|
case "ldltr":
|
|
val = (SCREENLAYOUT_LAYOUTDIR_LTR);
|
|
break;
|
|
case "small":
|
|
val = (SCREENSIZE_SMALL);
|
|
break;
|
|
case "normal":
|
|
val = (SCREENSIZE_NORMAL);
|
|
break;
|
|
case "large":
|
|
val = (SCREENSIZE_LARGE);
|
|
break;
|
|
case "xlarge":
|
|
val = (SCREENSIZE_XLARGE);
|
|
break;
|
|
case "long":
|
|
val = (SCREENLONG_YES);
|
|
break;
|
|
case "notlong":
|
|
val = (SCREENLONG_NO);
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
result = (result | val);
|
|
split[i]=null;
|
|
}
|
|
return (byte) result;
|
|
}
|
|
private static String decodeScreenLayout(ResConfig resConfig){
|
|
StringBuilder ret=new StringBuilder();
|
|
byte screenLayout=resConfig.getScreenLayoutValue();
|
|
switch (screenLayout & MASK_LAYOUTDIR) {
|
|
case SCREENLAYOUT_LAYOUTDIR_RTL:
|
|
ret.append("-ldrtl");
|
|
break;
|
|
case SCREENLAYOUT_LAYOUTDIR_LTR:
|
|
ret.append("-ldltr");
|
|
}
|
|
switch (screenLayout & MASK_SCREENSIZE) {
|
|
case SCREENSIZE_SMALL:
|
|
ret.append("-small");
|
|
break;
|
|
case SCREENSIZE_NORMAL:
|
|
ret.append("-normal");
|
|
break;
|
|
case SCREENSIZE_LARGE:
|
|
ret.append("-large");
|
|
break;
|
|
case SCREENSIZE_XLARGE:
|
|
ret.append("-xlarge");
|
|
break;
|
|
}
|
|
switch (screenLayout & MASK_SCREENLONG) {
|
|
case SCREENLONG_YES:
|
|
ret.append("-long");
|
|
break;
|
|
case SCREENLONG_NO:
|
|
ret.append("-notlong");
|
|
break;
|
|
}
|
|
return ret.toString();
|
|
}
|
|
public static String decodeScreenLayout(byte screenLayout){
|
|
StringBuilder ret=new StringBuilder();
|
|
switch (screenLayout & MASK_LAYOUTDIR) {
|
|
case SCREENLAYOUT_LAYOUTDIR_RTL:
|
|
ret.append("-ldrtl");
|
|
break;
|
|
case SCREENLAYOUT_LAYOUTDIR_LTR:
|
|
ret.append("-ldltr");
|
|
}
|
|
switch (screenLayout & MASK_SCREENSIZE) {
|
|
case SCREENSIZE_SMALL:
|
|
ret.append("-small");
|
|
break;
|
|
case SCREENSIZE_NORMAL:
|
|
ret.append("-normal");
|
|
break;
|
|
case SCREENSIZE_LARGE:
|
|
ret.append("-large");
|
|
break;
|
|
case SCREENSIZE_XLARGE:
|
|
ret.append("-xlarge");
|
|
break;
|
|
}
|
|
switch (screenLayout & MASK_SCREENLONG) {
|
|
case SCREENLONG_YES:
|
|
ret.append("-long");
|
|
break;
|
|
case SCREENLONG_NO:
|
|
ret.append("-notlong");
|
|
break;
|
|
}
|
|
if(ret.length()==0){
|
|
return null;
|
|
}
|
|
return ret.toString();
|
|
}
|
|
private static void encodeScreenLayout2(ResConfig resConfig, String[] split){
|
|
int screenLayout2=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
int val;
|
|
if("round".equals(s)){
|
|
val = (SCREENLAYOUT_ROUND_YES);
|
|
}else if("notround".equals(s)){
|
|
val = (SCREENLAYOUT_ROUND_NO);
|
|
}else {
|
|
continue;
|
|
}
|
|
screenLayout2 = (screenLayout2 | val);
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setScreenLayout2((byte) screenLayout2);
|
|
}
|
|
private static String decodeScreenLayout2(ResConfig resConfig){
|
|
StringBuilder ret=new StringBuilder();
|
|
switch (resConfig.getScreenLayout2() & MASK_SCREENROUND) {
|
|
case SCREENLAYOUT_ROUND_NO:
|
|
ret.append("-notround");
|
|
break;
|
|
case SCREENLAYOUT_ROUND_YES:
|
|
ret.append("-round");
|
|
break;
|
|
}
|
|
return ret.toString();
|
|
}
|
|
private static void encodeMcc(ResConfig resConfig, String[] split){
|
|
short sh=(short)0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
Matcher matcher=PATTERN_MCC_MNC.matcher(s);
|
|
if(!matcher.find()){
|
|
continue;
|
|
}
|
|
String mccMnc=matcher.group(1);
|
|
int val=Integer.parseInt(matcher.group(2));
|
|
if(val==0){
|
|
val=-1;
|
|
}
|
|
sh=(short)val;
|
|
if(!"mcc".equals(mccMnc)){
|
|
continue;
|
|
}
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setMcc(sh);
|
|
}
|
|
private static void encodeMnc(ResConfig resConfig, String[] split){
|
|
short sh=(short)0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
Matcher matcher=PATTERN_MCC_MNC.matcher(s);
|
|
if(!matcher.find()){
|
|
continue;
|
|
}
|
|
String mccMnc=matcher.group(1);
|
|
int val=Integer.parseInt(matcher.group(2));
|
|
sh=(short)val;
|
|
if(!"mnc".equals(mccMnc)){
|
|
continue;
|
|
}
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setMnc(sh);
|
|
}
|
|
private static String decodeMccMnc(ResConfig resConfig){
|
|
short mcc=resConfig.getMcc();
|
|
short mnc=resConfig.getMnc();
|
|
int size=resConfig.getConfigSize();
|
|
StringBuilder ret = new StringBuilder();
|
|
if (mcc != 0) {
|
|
ret.append("-mcc").append(String.format("%03d", mcc));
|
|
if (mnc != -1) {
|
|
if (mnc != 0) {
|
|
ret.append("-mnc");
|
|
if (size <= 32) {
|
|
if (mnc > 0 && mnc < 10) {
|
|
ret.append(String.format("%02d", mnc));
|
|
} else {
|
|
ret.append(String.format("%03d", mnc));
|
|
}
|
|
} else {
|
|
ret.append(mnc);
|
|
}
|
|
}
|
|
} else {
|
|
ret.append("-mnc00");
|
|
}
|
|
} else {
|
|
if (mnc != 0) {
|
|
ret.append("-mnc").append(mnc);
|
|
}
|
|
}
|
|
return ret.toString();
|
|
}
|
|
private static void encodeSmallestScreenWidthDp(ResConfig resConfig, String[] split){
|
|
int val=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
Matcher matcher=PATTERN_SCREEN_SMALLEST_DP.matcher(s);
|
|
if(!matcher.find()){
|
|
continue;
|
|
}
|
|
val=Integer.parseInt(matcher.group(1));
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setSmallestScreenWidthDp((short)val);
|
|
}
|
|
private static String decodeSmallestScreenWidthDp(ResConfig resConfig){
|
|
int smallestScreenWidthDp=resConfig.getSmallestScreenWidthDp();
|
|
StringBuilder builder=new StringBuilder();
|
|
if(smallestScreenWidthDp!=0){
|
|
builder.append("-sw");
|
|
builder.append(smallestScreenWidthDp);
|
|
builder.append("dp");
|
|
}
|
|
return builder.toString();
|
|
}
|
|
private static void encodeScreenHeightDp(ResConfig resConfig, String[] split){
|
|
int val=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
Matcher matcher=PATTERN_SCREEN_DP.matcher(s);
|
|
if(!matcher.find()){
|
|
continue;
|
|
}
|
|
String pre=matcher.group(1);
|
|
if(!pre.equals("h")){
|
|
continue;
|
|
}
|
|
val=Integer.parseInt(matcher.group(2));
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setScreenHeightDp((short)val);
|
|
}
|
|
private static String decodeScreenHeightDp(ResConfig resConfig){
|
|
int screenHeightDp=resConfig.getScreenHeightDp();
|
|
StringBuilder builder=new StringBuilder();
|
|
if(screenHeightDp!=0){
|
|
builder.append("-h");
|
|
builder.append(screenHeightDp);
|
|
builder.append("dp");
|
|
}
|
|
return builder.toString();
|
|
}
|
|
private static void encodeScreenWidthDp(ResConfig resConfig, String[] split){
|
|
int val=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
Matcher matcher=PATTERN_SCREEN_DP.matcher(s);
|
|
if(!matcher.find()){
|
|
continue;
|
|
}
|
|
String pre=matcher.group(1);
|
|
if(!pre.equals("w")){
|
|
continue;
|
|
}
|
|
val=Integer.parseInt(matcher.group(2));
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setScreenWidthDp((short)val);
|
|
}
|
|
private static String decodeScreenWidthDp(ResConfig resConfig){
|
|
int screenWidthDp=resConfig.getScreenWidthDp();
|
|
StringBuilder builder=new StringBuilder();
|
|
if(screenWidthDp!=0){
|
|
builder.append("-w");
|
|
builder.append(screenWidthDp);
|
|
builder.append("dp");
|
|
}
|
|
return builder.toString();
|
|
}
|
|
private static void encodeSdkVersion(ResConfig resConfig, String[] split){
|
|
int val=0;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
Matcher matcher=PATTERN_SDK_VERSION.matcher(s);
|
|
if(!matcher.find()){
|
|
continue;
|
|
}
|
|
val=Integer.parseInt(matcher.group(1));
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
resConfig.setSdkVersion((short)val);
|
|
}
|
|
private static String decodeSdkVersion(ResConfig resConfig){
|
|
int sdkVersion=resConfig.getSdkVersion();
|
|
StringBuilder builder=new StringBuilder();
|
|
if(sdkVersion!=0){
|
|
builder.append("-v");
|
|
builder.append(sdkVersion);
|
|
}
|
|
return builder.toString();
|
|
}
|
|
private static String decodeScreenSize(ResConfig resConfig){
|
|
short width=resConfig.getScreenWidth();
|
|
short height=resConfig.getScreenHeight();
|
|
if(width==0||height==0){
|
|
return "";
|
|
}
|
|
if (width > height) {
|
|
return String.format("%dx%d", width, height);
|
|
} else {
|
|
return String.format("%dx%d", height, width);
|
|
}
|
|
}
|
|
private static void encodeScreenSize(ResConfig resConfig, String[] split){
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
Matcher matcher=PATTERN_SCREEN_SIZE.matcher(s);
|
|
if(!matcher.find()){
|
|
continue;
|
|
}
|
|
int a=Integer.parseInt(matcher.group(1));
|
|
int b=Integer.parseInt(matcher.group(2));
|
|
short w;
|
|
short h;
|
|
if(a>b){
|
|
w=(short)a;
|
|
h=(short)b;
|
|
}else {
|
|
w=(short)b;
|
|
h=(short)a;
|
|
}
|
|
resConfig.setScreenSize(w, h);
|
|
split[i]=null;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static boolean isLanguageName(String str){
|
|
if(str==null){
|
|
return false;
|
|
}
|
|
Matcher matcher=PATTERN_LANG_NAME.matcher(str);
|
|
return matcher.find();
|
|
}
|
|
private static boolean isCountryName(String str){
|
|
if(str==null){
|
|
return false;
|
|
}
|
|
Matcher matcher=PATTERN_COUNTRY_NAME.matcher(str);
|
|
return matcher.find();
|
|
}
|
|
private static char[] toUpper(char[] chs){
|
|
for(int i=0;i<chs.length;i++){
|
|
chs[i]=Character.toUpperCase(chs[i]);
|
|
}
|
|
return chs;
|
|
}
|
|
private static boolean isNull(String[] split){
|
|
if(split==null){
|
|
return true;
|
|
}
|
|
if(split.length==0){
|
|
return true;
|
|
}
|
|
boolean result=true;
|
|
for(int i=0;i<split.length;i++){
|
|
String s=split[i];
|
|
if(s==null){
|
|
continue;
|
|
}
|
|
s=s.trim();
|
|
if(s.length()==0){
|
|
split[i]=null;
|
|
continue;
|
|
}
|
|
result=false;
|
|
}
|
|
return result;
|
|
}
|
|
private static boolean isDecimal(String str){
|
|
if(str==null){
|
|
return false;
|
|
}
|
|
Matcher matcher=PATTERN_NUMBER.matcher(str);
|
|
return matcher.find();
|
|
}
|
|
|
|
private static final Pattern PATTERN_SDK_VERSION=Pattern.compile("^-?v([0-9]+)$");
|
|
|
|
private static final Pattern PATTERN_SCREEN_DP=Pattern.compile("^([wh])([0-9]+)dp$");
|
|
|
|
private static final Pattern PATTERN_SCREEN_SMALLEST_DP=Pattern.compile("^sw([0-9]+)dp$");
|
|
|
|
private static final Pattern PATTERN_LANG_NAME=Pattern.compile("^[a-z]{2}$");
|
|
|
|
private static final Pattern PATTERN_COUNTRY_NAME=Pattern.compile("^[a-zA-Z]{2,3}$");
|
|
|
|
private static final Pattern PATTERN_MCC_MNC=Pattern.compile("^(m[cn]c)([0-9]{2,3})$");
|
|
|
|
private static final Pattern PATTERN_DENSITY=Pattern.compile("^([^\\s]+)dpi$");
|
|
|
|
private static final Pattern PATTERN_NUMBER=Pattern.compile("^[0-9]+$");
|
|
|
|
private static final Pattern PATTERN_SCREEN_SIZE=Pattern.compile("^-?([0-9]+)x([0-9]+)$");
|
|
|
|
|
|
public final static short MASK_LAYOUTDIR = 0xc0;
|
|
public final static short SCREENLAYOUT_LAYOUTDIR_ANY = 0x00;
|
|
public final static short SCREENLAYOUT_LAYOUTDIR_LTR = 0x40;
|
|
public final static short SCREENLAYOUT_LAYOUTDIR_RTL = 0x80;
|
|
public final static short SCREENLAYOUT_LAYOUTDIR_SHIFT = 0x06;
|
|
|
|
|
|
public final static byte MASK_SCREENSIZE = 0x0f;
|
|
public final static byte SCREENSIZE_ANY = 0x00;
|
|
public final static byte SCREENSIZE_SMALL = 0x01;
|
|
public final static byte SCREENSIZE_NORMAL = 0x02;
|
|
public final static byte SCREENSIZE_LARGE = 0x03;
|
|
public final static byte SCREENSIZE_XLARGE = 0x04;
|
|
|
|
public final static byte MASK_SCREENLONG = 0x30;
|
|
public final static byte SCREENLONG_ANY = 0x00;
|
|
public final static byte SCREENLONG_NO = 0x10;
|
|
public final static byte SCREENLONG_YES = 0x20;
|
|
|
|
|
|
public final static short MASK_SCREENROUND = 0x03;
|
|
public final static short SCREENLAYOUT_ROUND_ANY = 0;
|
|
public final static short SCREENLAYOUT_ROUND_NO = 0x1;
|
|
public final static short SCREENLAYOUT_ROUND_YES = 0x2;
|
|
|
|
|
|
public final static byte MASK_UI_MODE_TYPE = 0x0f;
|
|
public final static byte UI_MODE_TYPE_ANY = 0x00;
|
|
public final static byte UI_MODE_TYPE_NORMAL = 0x01;
|
|
public final static byte UI_MODE_TYPE_DESK = 0x02;
|
|
public final static byte UI_MODE_TYPE_CAR = 0x03;
|
|
public final static byte UI_MODE_TYPE_TELEVISION = 0x04;
|
|
public final static byte UI_MODE_TYPE_APPLIANCE = 0x05;
|
|
public final static byte UI_MODE_TYPE_WATCH = 0x06;
|
|
public final static byte UI_MODE_TYPE_VR_HEADSET = 0x07;
|
|
|
|
|
|
public final static byte MASK_UI_MODE_NIGHT = 0x30;
|
|
public final static byte UI_MODE_NIGHT_ANY = 0x00;
|
|
public final static byte UI_MODE_NIGHT_NO = 0x10;
|
|
public final static byte UI_MODE_NIGHT_YES = 0x20;
|
|
|
|
|
|
public final static byte UI_MODE_TYPE_GODZILLAUI = 0x0b;
|
|
public final static byte UI_MODE_TYPE_SMALLUI = 0x0c;
|
|
public final static byte UI_MODE_TYPE_MEDIUMUI = 0x0d;
|
|
public final static byte UI_MODE_TYPE_LARGEUI = 0x0e;
|
|
public final static byte UI_MODE_TYPE_HUGEUI = 0x0f;
|
|
|
|
|
|
public final static byte TOUCHSCREEN_ANY = 0;
|
|
public final static byte TOUCHSCREEN_NOTOUCH = 1;
|
|
public final static byte TOUCHSCREEN_STYLUS = 2;
|
|
public final static byte TOUCHSCREEN_FINGER = 3;
|
|
|
|
public final static byte MASK_KEYSHIDDEN = 0x3;
|
|
public final static byte KEYSHIDDEN_ANY = 0x0;
|
|
public final static byte KEYSHIDDEN_NO = 0x1;
|
|
public final static byte KEYSHIDDEN_YES = 0x2;
|
|
public final static byte KEYSHIDDEN_SOFT = 0x3;
|
|
|
|
private final static byte KEYBOARD_ANY = 0;
|
|
private final static byte KEYBOARD_NOKEYS = 1;
|
|
private final static byte KEYBOARD_QWERTY = 2;
|
|
private final static byte KEYBOARD_12KEY = 3;
|
|
|
|
public final static byte MASK_NAVHIDDEN = 0xc;
|
|
public final static byte NAVHIDDEN_ANY = 0x0;
|
|
public final static byte NAVHIDDEN_NO = 0x4;
|
|
public final static byte NAVHIDDEN_YES = 0x8;
|
|
|
|
|
|
private final static byte NAVIGATION_ANY = 0;
|
|
private final static byte NAVIGATION_NONAV = 1;
|
|
private final static byte NAVIGATION_DPAD = 2;
|
|
private final static byte NAVIGATION_TRACKBALL = 3;
|
|
private final static byte NAVIGATION_WHEEL = 4;
|
|
|
|
|
|
private final static int DENSITY_DEFAULT = 0;
|
|
private final static int DENSITY_LOW = 120;
|
|
private final static int DENSITY_MEDIUM = 160;
|
|
private final static int DENSITY_400 = 190;
|
|
private final static int DENSITY_TV = 213;
|
|
private final static int DENSITY_HIGH = 240;
|
|
private final static int DENSITY_XHIGH = 320;
|
|
private final static int DENSITY_XXHIGH = 480;
|
|
private final static int DENSITY_XXXHIGH = 640;
|
|
private final static int DENSITY_ANY = -2;
|
|
private final static int DENSITY_NONE = -1;
|
|
|
|
|
|
}
|
|
|