pebble/sdk/waftools/process_message_keys.py

230 lines
8.4 KiB
Python
Raw Permalink Normal View History

# Copyright 2024 Google LLC
#
# 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.
import json
from re import findall
from waflib.TaskGen import before_method, feature
from waflib import Logs, Task
from sdk_helpers import get_node_from_abspath
header = (
"""#pragma once
#include <stdint.h>
//
// AUTOGENERATED BY BUILD
// DO NOT MODIFY - CHANGES WILL BE OVERWRITTEN
//
""")
definitions_file = (
"""
#include <stdint.h>
//
// AUTOGENERATED BY BUILD
// DO NOT MODIFY - CHANGES WILL BE OVERWRITTEN
//
""")
def configure(conf):
"""
Configure the build by collecting all of the project's appKeys, as well the appKeys of any
dependencies, and writing them out to a header file and a JSON file for use in the project
:param conf: the ConfigureContext
:return: N/A
"""
if conf.env.BUILD_TYPE != 'lib':
if not dict(conf.env.PROJECT_INFO).get('enableMultiJS', False):
Logs.pprint("CYAN",
"WARNING: enableMultiJS is not enabled for this project. message_keys.json "
"will not be included in your project unless you add it to your "
"pebble-js-app.js file.")
keys = conf.env.PROJECT_INFO.get('messageKeys', conf.env.PROJECT_INFO.get('appKeys', []))
if conf.env.BUILD_TYPE == 'rocky':
if keys:
conf.fatal("Custom messageKeys are not supported for Rocky.js projects. Please "
"remove any messageKeys listed in your package.json file.")
else:
keys = {
"ControlKeyResetRequest": 1,
"ControlKeyResetComplete": 2,
"ControlKeyChunk": 3,
"ControlKeyUnsupportedError": 4,
}
key_list = []
key_dict = {}
block_message_keys = []
if keys:
if isinstance(keys, list):
key_list = keys
elif isinstance(keys, dict):
if conf.env.BUILD_TYPE == 'lib':
conf.fatal("Libraries can only specify an array of messageKeys; other object types "
"are not supported.")
key_dict = keys
else:
conf.fatal("You have specified an invalid messageKeys object in your project JSON "
"file.")
combined_key_list = key_list + key_dict.keys()
for lib in conf.env.LIB_JSON:
if not 'pebble' in lib or not 'messageKeys' in lib['pebble']:
continue
lib_keys = lib['pebble']['messageKeys']
if isinstance(lib_keys, list):
for key in lib_keys:
if key in combined_key_list:
conf.fatal("The messageKey '{}' has already been used and cannot be re-used by "
"the {} library.".format(key, lib['name']))
combined_key_list.append(key)
key_list.extend(lib_keys)
else:
conf.fatal("'{}' has an invalid messageKeys object. "
"Libraries can only specify an messageKeys array.".format(lib['name']))
if key_list:
next_key = 10000
multi_keys = [key for key in key_list if ']' in key]
single_keys = [key for key in key_list if ']' not in key]
for key in multi_keys:
try:
key_name, num_keys = findall(r"([\w]+)\[(\d+)\]$", key)[0]
except IndexError:
suggested_key_name = key.split('[', 1)[0]
conf.fatal("An invalid message key of `{}` was specified. Verify that a valid "
"length is specified if you are trying to allocate an array of keys "
"with a single identifier. For example, try `{}[2]`.".
format(key, suggested_key_name))
else:
key_dict.update({key_name: next_key})
next_key += int(num_keys)
block_message_keys.append(key_name)
key_dict.update({value: key for key, value in enumerate(single_keys, start=next_key)})
conf.env.PROJECT_INFO['messageKeys'] = key_dict
conf.env.PROJECT_INFO['appKeys'] = key_dict # Support legacy appinfo.json generation
conf.env.MESSAGE_KEYS = key_dict
conf.env.BLOCK_MESSAGE_KEYS = block_message_keys
bld_dir = conf.path.get_bld()
conf.env.MESSAGE_KEYS_HEADER = bld_dir.make_node('include/message_keys.auto.h').abspath()
if key_dict:
conf.env.MESSAGE_KEYS_DEFINITION = bld_dir.make_node('src/message_keys.auto.c').abspath()
conf.env.MESSAGE_KEYS_JSON = bld_dir.make_node('js/message_keys.json').abspath()
@feature('message_keys')
@before_method('cprogram', 'process_js', 'process_headers')
def process_message_keys(task_gen):
"""
Create the appropriate message key output files for the type of build, a header for a library,
and a header + JSON file for a library
:param task_gen: the task generator instance
:return: None
"""
message_keys = task_gen.env['MESSAGE_KEYS']
bld = task_gen.bld
# Create a header file that is included during lib/app builds
header_task = (
task_gen.create_task('message_key_header',
tgt=get_node_from_abspath(task_gen.bld,
getattr(task_gen.env,
'MESSAGE_KEYS_HEADER'))))
header_task.message_keys = message_keys
header_task.dep_vars = message_keys
if bld.env.BUILD_TYPE == 'lib' or not message_keys:
return
# Create a C file to satisfy any extern header files
definitions_task = (
task_gen.create_task('message_key_definitions',
tgt=get_node_from_abspath(task_gen.bld,
getattr(task_gen.env,
'MESSAGE_KEYS_DEFINITION'))))
definitions_task.message_keys = message_keys
definitions_task.dep_vars = message_keys
# Create a JSON file for apps to require
bld.path.get_bld().make_node('js').mkdir()
json_task = (
task_gen.create_task('message_key_json',
tgt=get_node_from_abspath(task_gen.bld,
getattr(task_gen.env, 'MESSAGE_KEYS_JSON'))))
json_task.message_keys = message_keys
json_task.dep_vars = message_keys
@Task.update_outputs
class message_key_header(Task.Task):
"""
Task class for creating a header file with the message key definitions for the project
"""
def run(self):
"""
This method executes when the message key header task runs
:return: N/A
"""
self.outputs[0].parent.mkdir()
with open(self.outputs[0].abspath(), 'w') as f:
f.write(header)
for k, v in sorted(self.message_keys.items(), key=lambda x: x[0]):
f.write("extern uint32_t MESSAGE_KEY_{};\n".format(k))
@Task.update_outputs
class message_key_definitions(Task.Task):
"""
Task class for creating a C definitions file with the message key definitions for the project
"""
def run(self):
"""
This method executes when the message key definitions task runs
:return: N/A
"""
self.outputs[0].parent.mkdir()
with open(self.outputs[0].abspath(), 'w') as f:
f.write(definitions_file)
for k, v in sorted(self.message_keys.items(), key=lambda x: x[0]):
f.write("uint32_t MESSAGE_KEY_{} = {};\n".format(k, v))
@Task.update_outputs
class message_key_json(Task.Task):
"""
Task class for creating a JSON file with the message key definitions for the project
"""
def run(self):
"""
This method executes when the message key header task runs
:return: N/A
"""
self.outputs[0].parent.mkdir()
with open(self.outputs[0].abspath(), 'w') as f:
json.dump(self.message_keys, f, sort_keys=True, indent=4, separators=(',', ': '))