Adding upstream version 0.0~git20250520.a1d9079+dfsg.
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
parent
590ac7ff5f
commit
20149b7f3a
GPG key ID:
FBB4F0E80A80222F
456 changed files with 70406 additions and 0 deletions
833
internal/binres/table.go
Normal file
833
internal/binres/table.go
Normal file
|
|
@ -0,0 +1,833 @@
|
|||
// Copyright 2015 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package binres
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"compress/gzip"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"strings"
|
||||
"unicode/utf16"
|
||||
)
|
||||
|
||||
const NoEntry = 0xFFFFFFFF
|
||||
|
||||
// TableRef uniquely identifies entries within a resource table.
|
||||
type TableRef uint32
|
||||
|
||||
// Resolve returns the Entry of TableRef in the given table.
|
||||
//
|
||||
// A TableRef is structured as follows:
|
||||
//
|
||||
// 0xpptteeee
|
||||
// pp: package index
|
||||
// tt: type spec index in package
|
||||
// eeee: entry index in type spec
|
||||
//
|
||||
// The package and type spec values start at 1 for the first item,
|
||||
// to help catch cases where they have not been supplied.
|
||||
func (ref TableRef) Resolve(tbl *Table) (*Entry, error) {
|
||||
pkg := tbl.pkgs[uint8(ref>>24)-1]
|
||||
spec := pkg.specs[uint8(ref>>16)-1]
|
||||
idx := uint16(ref)
|
||||
|
||||
for _, typ := range spec.types {
|
||||
if idx < uint16(len(typ.entries)) {
|
||||
nt := typ.entries[idx]
|
||||
if nt == nil {
|
||||
return nil, errors.New("nil entry match")
|
||||
}
|
||||
return nt, nil
|
||||
}
|
||||
}
|
||||
|
||||
return nil, errors.New("failed to resolve table reference")
|
||||
}
|
||||
|
||||
// Table is a container for packaged resources. Resource values within a package
|
||||
// are obtained through pool while resource names and identifiers are obtained
|
||||
// through each package's type and key pools respectively.
|
||||
type Table struct {
|
||||
chunkHeader
|
||||
pool *Pool
|
||||
pkgs []*Package
|
||||
}
|
||||
|
||||
// NewMipmapTable returns a resource table initialized for a single xxxhdpi mipmap resource
|
||||
// and the path to write resource data to.
|
||||
func NewMipmapTable(pkgname string) (*Table, string) {
|
||||
pkg := &Package{id: 127, name: pkgname, typePool: &Pool{}, keyPool: &Pool{}}
|
||||
|
||||
attr := pkg.typePool.ref("attr")
|
||||
mipmap := pkg.typePool.ref("mipmap")
|
||||
icon := pkg.keyPool.ref("icon")
|
||||
|
||||
nt := &Entry{values: []*Value{{data: &Data{Type: DataString}}}}
|
||||
typ := &Type{id: 2, indices: []uint32{0}, entries: []*Entry{nt}}
|
||||
typ.config.screenType.density = 640
|
||||
typ.config.version.sdk = 4
|
||||
|
||||
pkg.specs = append(pkg.specs,
|
||||
&TypeSpec{
|
||||
id: uint8(attr) + 1, //1,
|
||||
},
|
||||
&TypeSpec{
|
||||
id: uint8(mipmap) + 1, //2,
|
||||
entryCount: 1,
|
||||
entries: []uint32{uint32(icon)}, // {0}
|
||||
types: []*Type{typ},
|
||||
})
|
||||
|
||||
pkg.lastPublicType = uint32(len(pkg.typePool.strings)) // 2
|
||||
pkg.lastPublicKey = uint32(len(pkg.keyPool.strings)) // 1
|
||||
|
||||
name := "res/mipmap-xxxhdpi-v4/icon.png"
|
||||
tbl := &Table{pool: &Pool{}, pkgs: []*Package{pkg}}
|
||||
tbl.pool.ref(name)
|
||||
return tbl, name
|
||||
}
|
||||
|
||||
// OpenSDKTable decodes resources.arsc from sdk platform jar.
|
||||
func OpenSDKTable() (*Table, error) {
|
||||
bin, err := apiResources()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
tbl := new(Table)
|
||||
if err := tbl.UnmarshalBinary(bin); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return tbl, nil
|
||||
}
|
||||
|
||||
// OpenTable decodes the prepacked resources.arsc for the supported sdk platform.
|
||||
func OpenTable() (*Table, error) {
|
||||
zr, err := gzip.NewReader(bytes.NewReader(arsc))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("gzip: %v", err)
|
||||
}
|
||||
defer zr.Close()
|
||||
|
||||
var buf bytes.Buffer
|
||||
if _, err := io.Copy(&buf, zr); err != nil {
|
||||
return nil, fmt.Errorf("io: %v", err)
|
||||
}
|
||||
tbl := new(Table)
|
||||
if err := tbl.UnmarshalBinary(buf.Bytes()); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return tbl, nil
|
||||
}
|
||||
|
||||
// SpecByName parses the spec name from an entry string if necessary and returns
|
||||
// the Package and TypeSpec associated with that name along with their respective
|
||||
// indices.
|
||||
//
|
||||
// For example:
|
||||
//
|
||||
// tbl.SpecByName("@android:style/Theme.NoTitleBar")
|
||||
// tbl.SpecByName("style")
|
||||
//
|
||||
// Both locate the spec by name "style".
|
||||
func (tbl *Table) SpecByName(name string) (int, *Package, int, *TypeSpec, error) {
|
||||
n := strings.TrimPrefix(name, "@android:")
|
||||
n = strings.Split(n, "/")[0]
|
||||
for pp, pkg := range tbl.pkgs {
|
||||
for tt, spec := range pkg.specs {
|
||||
if n == pkg.typePool.strings[spec.id-1] {
|
||||
return pp, pkg, tt, spec, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0, nil, 0, nil, fmt.Errorf("spec by name not found: %q", name)
|
||||
}
|
||||
|
||||
// RefByName returns the TableRef by a given name. The ref may be used to resolve the
|
||||
// associated Entry and is used for the generation of binary manifest files.
|
||||
func (tbl *Table) RefByName(name string) (TableRef, error) {
|
||||
pp, pkg, tt, spec, err := tbl.SpecByName(name)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
q := strings.Split(name, "/")
|
||||
if len(q) != 2 {
|
||||
return 0, fmt.Errorf("invalid entry format, missing forward-slash: %q", name)
|
||||
}
|
||||
n := q[1]
|
||||
|
||||
for _, t := range spec.types {
|
||||
for eeee, nt := range t.entries {
|
||||
if nt == nil { // NoEntry
|
||||
continue
|
||||
}
|
||||
if n == pkg.keyPool.strings[nt.key] {
|
||||
return TableRef(uint32(eeee) | uint32(tt+1)<<16 | uint32(pp+1)<<24), nil
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0, fmt.Errorf("failed to find table ref by %q", name)
|
||||
}
|
||||
|
||||
func (tbl *Table) UnmarshalBinary(bin []byte) error {
|
||||
if err := (&tbl.chunkHeader).UnmarshalBinary(bin); err != nil {
|
||||
return err
|
||||
}
|
||||
if tbl.typ != ResTable {
|
||||
return fmt.Errorf("unexpected resource type %s, want %s", tbl.typ, ResTable)
|
||||
}
|
||||
|
||||
npkgs := btou32(bin[8:])
|
||||
tbl.pkgs = make([]*Package, npkgs)
|
||||
|
||||
buf := bin[tbl.headerByteSize:]
|
||||
|
||||
tbl.pool = new(Pool)
|
||||
if err := tbl.pool.UnmarshalBinary(buf); err != nil {
|
||||
return err
|
||||
}
|
||||
buf = buf[tbl.pool.size():]
|
||||
for i := range tbl.pkgs {
|
||||
pkg := new(Package)
|
||||
if err := pkg.UnmarshalBinary(buf); err != nil {
|
||||
return err
|
||||
}
|
||||
tbl.pkgs[i] = pkg
|
||||
buf = buf[pkg.byteSize:]
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (tbl *Table) MarshalBinary() ([]byte, error) {
|
||||
bin := make([]byte, 12)
|
||||
putu16(bin, uint16(ResTable))
|
||||
putu16(bin[2:], 12)
|
||||
putu32(bin[8:], uint32(len(tbl.pkgs)))
|
||||
|
||||
if tbl.pool.IsUTF8() {
|
||||
tbl.pool.flags ^= UTF8Flag
|
||||
defer func() {
|
||||
tbl.pool.flags |= UTF8Flag
|
||||
}()
|
||||
}
|
||||
|
||||
b, err := tbl.pool.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bin = append(bin, b...)
|
||||
|
||||
for _, pkg := range tbl.pkgs {
|
||||
b, err = pkg.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bin = append(bin, b...)
|
||||
}
|
||||
|
||||
putu32(bin[4:], uint32(len(bin)))
|
||||
|
||||
return bin, nil
|
||||
}
|
||||
|
||||
// Package contains a collection of resource data types.
|
||||
type Package struct {
|
||||
chunkHeader
|
||||
|
||||
id uint32
|
||||
name string
|
||||
|
||||
lastPublicType uint32 // last index into typePool that is for public use
|
||||
lastPublicKey uint32 // last index into keyPool that is for public use
|
||||
|
||||
typePool *Pool // type names; e.g. theme
|
||||
keyPool *Pool // resource names; e.g. Theme.NoTitleBar
|
||||
|
||||
aliases []*StagedAlias
|
||||
specs []*TypeSpec
|
||||
}
|
||||
|
||||
func (pkg *Package) UnmarshalBinary(bin []byte) error {
|
||||
if err := (&pkg.chunkHeader).UnmarshalBinary(bin); err != nil {
|
||||
return err
|
||||
}
|
||||
if pkg.typ != ResTablePackage {
|
||||
return errWrongType(pkg.typ, ResTablePackage)
|
||||
}
|
||||
|
||||
pkg.id = btou32(bin[8:])
|
||||
|
||||
var name []uint16
|
||||
for i := 0; i < 128; i++ {
|
||||
x := btou16(bin[12+i*2:])
|
||||
if x == 0 {
|
||||
break
|
||||
}
|
||||
name = append(name, x)
|
||||
}
|
||||
pkg.name = string(utf16.Decode(name))
|
||||
|
||||
typeOffset := btou32(bin[268:]) // 0 if inheriting from another package
|
||||
pkg.lastPublicType = btou32(bin[272:])
|
||||
keyOffset := btou32(bin[276:]) // 0 if inheriting from another package
|
||||
pkg.lastPublicKey = btou32(bin[280:])
|
||||
|
||||
var idOffset uint32 // value determined by either typePool or keyPool below
|
||||
|
||||
if typeOffset != 0 {
|
||||
pkg.typePool = new(Pool)
|
||||
if err := pkg.typePool.UnmarshalBinary(bin[typeOffset:]); err != nil {
|
||||
return err
|
||||
}
|
||||
idOffset = typeOffset + pkg.typePool.byteSize
|
||||
}
|
||||
|
||||
if keyOffset != 0 {
|
||||
pkg.keyPool = new(Pool)
|
||||
if err := pkg.keyPool.UnmarshalBinary(bin[keyOffset:]); err != nil {
|
||||
return err
|
||||
}
|
||||
idOffset = keyOffset + pkg.keyPool.byteSize
|
||||
}
|
||||
|
||||
if idOffset == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
buf := bin[idOffset:pkg.byteSize]
|
||||
for len(buf) > 0 {
|
||||
t := ResType(btou16(buf))
|
||||
switch t {
|
||||
case ResTableTypeSpec:
|
||||
spec := new(TypeSpec)
|
||||
if err := spec.UnmarshalBinary(buf); err != nil {
|
||||
return err
|
||||
}
|
||||
pkg.specs = append(pkg.specs, spec)
|
||||
buf = buf[spec.byteSize:]
|
||||
case ResTableType:
|
||||
typ := new(Type)
|
||||
if err := typ.UnmarshalBinary(buf); err != nil {
|
||||
return err
|
||||
}
|
||||
last := pkg.specs[len(pkg.specs)-1]
|
||||
last.types = append(last.types, typ)
|
||||
buf = buf[typ.byteSize:]
|
||||
case ResTableStagedAlias:
|
||||
alias := new(StagedAlias)
|
||||
if err := alias.UnmarshalBinary(buf); err != nil {
|
||||
return err
|
||||
}
|
||||
pkg.aliases = append(pkg.aliases, alias)
|
||||
buf = buf[alias.byteSize:]
|
||||
default:
|
||||
return errWrongType(t, ResTableTypeSpec, ResTableType, ResTableStagedAlias)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (pkg *Package) MarshalBinary() ([]byte, error) {
|
||||
// Package header size is determined by C++ struct ResTable_package
|
||||
// see frameworks/base/include/ResourceTypes.h
|
||||
bin := make([]byte, 288)
|
||||
putu16(bin, uint16(ResTablePackage))
|
||||
putu16(bin[2:], 288)
|
||||
|
||||
putu32(bin[8:], pkg.id)
|
||||
p := utf16.Encode([]rune(pkg.name))
|
||||
for i, x := range p {
|
||||
putu16(bin[12+i*2:], x)
|
||||
}
|
||||
|
||||
if pkg.typePool != nil {
|
||||
if pkg.typePool.IsUTF8() {
|
||||
pkg.typePool.flags ^= UTF8Flag
|
||||
defer func() {
|
||||
pkg.typePool.flags |= UTF8Flag
|
||||
}()
|
||||
}
|
||||
|
||||
b, err := pkg.typePool.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
putu32(bin[268:], uint32(len(bin)))
|
||||
putu32(bin[272:], pkg.lastPublicType)
|
||||
bin = append(bin, b...)
|
||||
}
|
||||
|
||||
if pkg.keyPool != nil {
|
||||
if pkg.keyPool.IsUTF8() {
|
||||
pkg.keyPool.flags ^= UTF8Flag
|
||||
defer func() {
|
||||
pkg.keyPool.flags |= UTF8Flag
|
||||
}()
|
||||
}
|
||||
b, err := pkg.keyPool.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
putu32(bin[276:], uint32(len(bin)))
|
||||
putu32(bin[280:], pkg.lastPublicKey)
|
||||
bin = append(bin, b...)
|
||||
}
|
||||
|
||||
for _, alias := range pkg.aliases {
|
||||
b, err := alias.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bin = append(bin, b...)
|
||||
}
|
||||
|
||||
for _, spec := range pkg.specs {
|
||||
b, err := spec.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bin = append(bin, b...)
|
||||
}
|
||||
|
||||
putu32(bin[4:], uint32(len(bin)))
|
||||
return bin, nil
|
||||
}
|
||||
|
||||
// TypeSpec provides a specification for the resources defined by a particular type.
|
||||
type TypeSpec struct {
|
||||
chunkHeader
|
||||
id uint8 // id-1 is name index in Package.typePool
|
||||
res0 uint8 // must be 0
|
||||
res1 uint16 // must be 0
|
||||
entryCount uint32 // number of uint32 entry configuration masks that follow
|
||||
|
||||
entries []uint32 // entry configuration masks
|
||||
types []*Type
|
||||
}
|
||||
|
||||
func (spec *TypeSpec) UnmarshalBinary(bin []byte) error {
|
||||
if err := (&spec.chunkHeader).UnmarshalBinary(bin); err != nil {
|
||||
return err
|
||||
}
|
||||
if spec.typ != ResTableTypeSpec {
|
||||
return errWrongType(spec.typ, ResTableTypeSpec)
|
||||
}
|
||||
spec.id = uint8(bin[8])
|
||||
spec.res0 = uint8(bin[9])
|
||||
spec.res1 = btou16(bin[10:])
|
||||
spec.entryCount = btou32(bin[12:])
|
||||
|
||||
spec.entries = make([]uint32, spec.entryCount)
|
||||
for i := range spec.entries {
|
||||
spec.entries[i] = btou32(bin[16+i*4:])
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (spec *TypeSpec) MarshalBinary() ([]byte, error) {
|
||||
bin := make([]byte, 16+len(spec.entries)*4)
|
||||
putu16(bin, uint16(ResTableTypeSpec))
|
||||
putu16(bin[2:], 16)
|
||||
putu32(bin[4:], uint32(len(bin)))
|
||||
|
||||
bin[8] = byte(spec.id)
|
||||
// [9] = 0
|
||||
// [10:12] = 0
|
||||
putu32(bin[12:], uint32(len(spec.entries)))
|
||||
for i, x := range spec.entries {
|
||||
putu32(bin[16+i*4:], x)
|
||||
}
|
||||
|
||||
for _, typ := range spec.types {
|
||||
b, err := typ.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bin = append(bin, b...)
|
||||
}
|
||||
|
||||
return bin, nil
|
||||
}
|
||||
|
||||
// Type provides a collection of entries for a specific device configuration.
|
||||
type Type struct {
|
||||
chunkHeader
|
||||
id uint8
|
||||
res0 uint8 // must be 0
|
||||
res1 uint16 // must be 0
|
||||
entryCount uint32 // number of uint32 entry configuration masks that follow
|
||||
entriesStart uint32 // offset from header where Entry data starts
|
||||
|
||||
// configuration this collection of entries is designed for
|
||||
config struct {
|
||||
size uint32
|
||||
imsi struct {
|
||||
mcc uint16 // mobile country code
|
||||
mnc uint16 // mobile network code
|
||||
}
|
||||
locale struct {
|
||||
language uint16
|
||||
country uint16
|
||||
}
|
||||
screenType struct {
|
||||
orientation uint8
|
||||
touchscreen uint8
|
||||
density uint16
|
||||
}
|
||||
input struct {
|
||||
keyboard uint8
|
||||
navigation uint8
|
||||
inputFlags uint8
|
||||
inputPad0 uint8
|
||||
}
|
||||
screenSize struct {
|
||||
width uint16
|
||||
height uint16
|
||||
}
|
||||
version struct {
|
||||
sdk uint16
|
||||
minor uint16 // always 0
|
||||
}
|
||||
screenConfig struct {
|
||||
layout uint8
|
||||
uiMode uint8
|
||||
smallestWidthDP uint16
|
||||
}
|
||||
screenSizeDP struct {
|
||||
width uint16
|
||||
height uint16
|
||||
}
|
||||
}
|
||||
|
||||
indices []uint32 // values that map to typePool
|
||||
entries []*Entry
|
||||
}
|
||||
|
||||
func (typ *Type) UnmarshalBinary(bin []byte) error {
|
||||
if err := (&typ.chunkHeader).UnmarshalBinary(bin); err != nil {
|
||||
return err
|
||||
}
|
||||
if typ.typ != ResTableType {
|
||||
return errWrongType(typ.typ, ResTableType)
|
||||
}
|
||||
|
||||
typ.id = uint8(bin[8])
|
||||
typ.res0 = uint8(bin[9])
|
||||
typ.res1 = btou16(bin[10:])
|
||||
typ.entryCount = btou32(bin[12:])
|
||||
typ.entriesStart = btou32(bin[16:])
|
||||
|
||||
if typ.res0 != 0 || typ.res1 != 0 {
|
||||
return fmt.Errorf("res0 res1 not zero")
|
||||
}
|
||||
|
||||
typ.config.size = btou32(bin[20:])
|
||||
typ.config.imsi.mcc = btou16(bin[24:])
|
||||
typ.config.imsi.mnc = btou16(bin[26:])
|
||||
typ.config.locale.language = btou16(bin[28:])
|
||||
typ.config.locale.country = btou16(bin[30:])
|
||||
typ.config.screenType.orientation = uint8(bin[32])
|
||||
typ.config.screenType.touchscreen = uint8(bin[33])
|
||||
typ.config.screenType.density = btou16(bin[34:])
|
||||
typ.config.input.keyboard = uint8(bin[36])
|
||||
typ.config.input.navigation = uint8(bin[37])
|
||||
typ.config.input.inputFlags = uint8(bin[38])
|
||||
typ.config.input.inputPad0 = uint8(bin[39])
|
||||
typ.config.screenSize.width = btou16(bin[40:])
|
||||
typ.config.screenSize.height = btou16(bin[42:])
|
||||
typ.config.version.sdk = btou16(bin[44:])
|
||||
typ.config.version.minor = btou16(bin[46:])
|
||||
typ.config.screenConfig.layout = uint8(bin[48])
|
||||
typ.config.screenConfig.uiMode = uint8(bin[49])
|
||||
typ.config.screenConfig.smallestWidthDP = btou16(bin[50:])
|
||||
typ.config.screenSizeDP.width = btou16(bin[52:])
|
||||
typ.config.screenSizeDP.height = btou16(bin[54:])
|
||||
|
||||
// fmt.Println("language/country:", u16tos(typ.config.locale.language), u16tos(typ.config.locale.country))
|
||||
|
||||
buf := bin[typ.headerByteSize:typ.entriesStart]
|
||||
if len(buf) != 4*int(typ.entryCount) {
|
||||
return fmt.Errorf("index buffer len[%v] doesn't match entryCount[%v]", len(buf), typ.entryCount)
|
||||
}
|
||||
|
||||
typ.indices = make([]uint32, typ.entryCount)
|
||||
for i := range typ.indices {
|
||||
typ.indices[i] = btou32(buf[i*4:])
|
||||
}
|
||||
|
||||
typ.entries = make([]*Entry, typ.entryCount)
|
||||
|
||||
for i, x := range typ.indices {
|
||||
if x == NoEntry {
|
||||
continue
|
||||
}
|
||||
nt := &Entry{}
|
||||
if err := nt.UnmarshalBinary(bin[typ.entriesStart+x:]); err != nil {
|
||||
return err
|
||||
}
|
||||
typ.entries[i] = nt
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (typ *Type) MarshalBinary() ([]byte, error) {
|
||||
bin := make([]byte, 56+len(typ.entries)*4)
|
||||
putu16(bin, uint16(ResTableType))
|
||||
putu16(bin[2:], 56)
|
||||
|
||||
bin[8] = byte(typ.id)
|
||||
// [9] = 0
|
||||
// [10:12] = 0
|
||||
putu32(bin[12:], uint32(len(typ.entries)))
|
||||
putu32(bin[16:], uint32(56+len(typ.entries)*4))
|
||||
|
||||
// assure typ.config.size is always written as 36; extended configuration beyond supported
|
||||
// API level is not supported by this marshal implementation but will be forward-compatible.
|
||||
putu32(bin[20:], 36)
|
||||
|
||||
putu16(bin[24:], typ.config.imsi.mcc)
|
||||
putu16(bin[26:], typ.config.imsi.mnc)
|
||||
putu16(bin[28:], typ.config.locale.language)
|
||||
putu16(bin[30:], typ.config.locale.country)
|
||||
bin[32] = typ.config.screenType.orientation
|
||||
bin[33] = typ.config.screenType.touchscreen
|
||||
putu16(bin[34:], typ.config.screenType.density)
|
||||
bin[36] = typ.config.input.keyboard
|
||||
bin[37] = typ.config.input.navigation
|
||||
bin[38] = typ.config.input.inputFlags
|
||||
bin[39] = typ.config.input.inputPad0
|
||||
putu16(bin[40:], typ.config.screenSize.width)
|
||||
putu16(bin[42:], typ.config.screenSize.height)
|
||||
putu16(bin[44:], typ.config.version.sdk)
|
||||
putu16(bin[46:], typ.config.version.minor)
|
||||
bin[48] = typ.config.screenConfig.layout
|
||||
bin[49] = typ.config.screenConfig.uiMode
|
||||
putu16(bin[50:], typ.config.screenConfig.smallestWidthDP)
|
||||
putu16(bin[52:], typ.config.screenSizeDP.width)
|
||||
putu16(bin[54:], typ.config.screenSizeDP.height)
|
||||
|
||||
var ntbin []byte
|
||||
for i, nt := range typ.entries {
|
||||
if nt == nil { // NoEntry
|
||||
putu32(bin[56+i*4:], NoEntry)
|
||||
continue
|
||||
}
|
||||
putu32(bin[56+i*4:], uint32(len(ntbin)))
|
||||
b, err := nt.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
ntbin = append(ntbin, b...)
|
||||
}
|
||||
bin = append(bin, ntbin...)
|
||||
|
||||
putu32(bin[4:], uint32(len(bin)))
|
||||
return bin, nil
|
||||
}
|
||||
|
||||
type StagedAliasEntry struct {
|
||||
stagedID uint32
|
||||
finalizedID uint32
|
||||
}
|
||||
|
||||
func (ae *StagedAliasEntry) MarshalBinary() ([]byte, error) {
|
||||
bin := make([]byte, 8)
|
||||
putu32(bin, ae.stagedID)
|
||||
putu32(bin[4:], ae.finalizedID)
|
||||
return bin, nil
|
||||
}
|
||||
|
||||
func (ae *StagedAliasEntry) UnmarshalBinary(bin []byte) error {
|
||||
ae.stagedID = btou32(bin)
|
||||
ae.finalizedID = btou32(bin[4:])
|
||||
return nil
|
||||
}
|
||||
|
||||
type StagedAlias struct {
|
||||
chunkHeader
|
||||
count uint32
|
||||
entries []StagedAliasEntry
|
||||
}
|
||||
|
||||
func (a *StagedAlias) UnmarshalBinary(bin []byte) error {
|
||||
if err := (&a.chunkHeader).UnmarshalBinary(bin); err != nil {
|
||||
return err
|
||||
}
|
||||
if a.typ != ResTableStagedAlias {
|
||||
return errWrongType(a.typ, ResTableStagedAlias)
|
||||
}
|
||||
a.count = btou32(bin[8:])
|
||||
a.entries = make([]StagedAliasEntry, a.count)
|
||||
for i := range a.entries {
|
||||
if err := a.entries[i].UnmarshalBinary(bin[12+i*8:]); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (a *StagedAlias) MarshalBinary() ([]byte, error) {
|
||||
chunkHeaderBin, err := a.chunkHeader.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
countBin := make([]byte, 4)
|
||||
putu32(countBin, a.count)
|
||||
bin := append(chunkHeaderBin, countBin...)
|
||||
for _, entry := range a.entries {
|
||||
entryBin, err := entry.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bin = append(bin, entryBin...)
|
||||
}
|
||||
return bin, nil
|
||||
}
|
||||
|
||||
// Entry is a resource key typically followed by a value or resource map.
|
||||
type Entry struct {
|
||||
size uint16
|
||||
flags uint16
|
||||
key PoolRef // ref into key pool
|
||||
|
||||
// only filled if this is a map entry; when size is 16
|
||||
parent TableRef // id of parent mapping or zero if none
|
||||
count uint32 // name and value pairs that follow for FlagComplex
|
||||
|
||||
values []*Value
|
||||
}
|
||||
|
||||
func (nt *Entry) UnmarshalBinary(bin []byte) error {
|
||||
nt.size = btou16(bin)
|
||||
nt.flags = btou16(bin[2:])
|
||||
nt.key = PoolRef(btou32(bin[4:]))
|
||||
|
||||
if nt.size == 16 {
|
||||
nt.parent = TableRef(btou32(bin[8:]))
|
||||
nt.count = btou32(bin[12:])
|
||||
nt.values = make([]*Value, nt.count)
|
||||
for i := range nt.values {
|
||||
val := &Value{}
|
||||
if err := val.UnmarshalBinary(bin[16+i*12:]); err != nil {
|
||||
return err
|
||||
}
|
||||
nt.values[i] = val
|
||||
}
|
||||
} else {
|
||||
data := &Data{}
|
||||
if err := data.UnmarshalBinary(bin[8:]); err != nil {
|
||||
return err
|
||||
}
|
||||
// TODO boxing data not strictly correct as binary repr isn't of Value.
|
||||
nt.values = append(nt.values, &Value{0, data})
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (nt *Entry) MarshalBinary() ([]byte, error) {
|
||||
bin := make([]byte, 8)
|
||||
sz := nt.size
|
||||
if sz == 0 {
|
||||
sz = 8
|
||||
}
|
||||
putu16(bin, sz)
|
||||
putu16(bin[2:], nt.flags)
|
||||
putu32(bin[4:], uint32(nt.key))
|
||||
|
||||
if sz == 16 {
|
||||
bin = append(bin, make([]byte, 8+len(nt.values)*12)...)
|
||||
putu32(bin[8:], uint32(nt.parent))
|
||||
putu32(bin[12:], uint32(len(nt.values)))
|
||||
for i, val := range nt.values {
|
||||
b, err := val.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
copy(bin[16+i*12:], b)
|
||||
}
|
||||
} else {
|
||||
b, err := nt.values[0].data.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bin = append(bin, b...)
|
||||
}
|
||||
|
||||
return bin, nil
|
||||
}
|
||||
|
||||
type Value struct {
|
||||
name TableRef
|
||||
data *Data
|
||||
}
|
||||
|
||||
func (val *Value) UnmarshalBinary(bin []byte) error {
|
||||
val.name = TableRef(btou32(bin))
|
||||
val.data = &Data{}
|
||||
return val.data.UnmarshalBinary(bin[4:])
|
||||
}
|
||||
|
||||
func (val *Value) MarshalBinary() ([]byte, error) {
|
||||
bin := make([]byte, 12)
|
||||
putu32(bin, uint32(val.name))
|
||||
b, err := val.data.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
copy(bin[4:], b)
|
||||
return bin, nil
|
||||
}
|
||||
|
||||
type DataType uint8
|
||||
|
||||
// explicitly defined for clarity and resolvability with apt source
|
||||
const (
|
||||
DataNull DataType = 0x00 // either 0 or 1 for resource undefined or empty
|
||||
DataReference DataType = 0x01 // ResTable_ref, a reference to another resource table entry
|
||||
DataAttribute DataType = 0x02 // attribute resource identifier
|
||||
DataString DataType = 0x03 // index into the containing resource table's global value string pool
|
||||
DataFloat DataType = 0x04 // single-precision floating point number
|
||||
DataDimension DataType = 0x05 // complex number encoding a dimension value, such as "100in"
|
||||
DataFraction DataType = 0x06 // complex number encoding a fraction of a container
|
||||
DataDynamicReference DataType = 0x07 // dynamic ResTable_ref, which needs to be resolved before it can be used like a TYPE_REFERENCE.
|
||||
DataIntDec DataType = 0x10 // raw integer value of the form n..n
|
||||
DataIntHex DataType = 0x11 // raw integer value of the form 0xn..n
|
||||
DataIntBool DataType = 0x12 // either 0 or 1, for input "false" or "true"
|
||||
DataIntColorARGB8 DataType = 0x1c // raw integer value of the form #aarrggbb
|
||||
DataIntColorRGB8 DataType = 0x1d // raw integer value of the form #rrggbb
|
||||
DataIntColorARGB4 DataType = 0x1e // raw integer value of the form #argb
|
||||
DataIntColorRGB4 DataType = 0x1f // raw integer value of the form #rgb
|
||||
)
|
||||
|
||||
type Data struct {
|
||||
ByteSize uint16
|
||||
Res0 uint8 // always 0, useful for debugging bad read offsets
|
||||
Type DataType
|
||||
Value uint32
|
||||
}
|
||||
|
||||
func (d *Data) UnmarshalBinary(bin []byte) error {
|
||||
d.ByteSize = btou16(bin)
|
||||
d.Res0 = uint8(bin[2])
|
||||
d.Type = DataType(bin[3])
|
||||
d.Value = btou32(bin[4:])
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *Data) MarshalBinary() ([]byte, error) {
|
||||
bin := make([]byte, 8)
|
||||
putu16(bin, 8)
|
||||
bin[2] = byte(d.Res0)
|
||||
bin[3] = byte(d.Type)
|
||||
putu32(bin[4:], d.Value)
|
||||
return bin, nil
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue