1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "js_typeface.h"
17 #include "js_typefacearguments.h"
18
19 #include "native_value.h"
20
21 #include "js_drawing_utils.h"
22 #if defined(ROSEN_OHOS) || defined(ROSEN_ARKUI_X)
23 #include "tool_napi/js_tool.h"
24 #endif
25
26 namespace OHOS::Rosen {
27 namespace Drawing {
28 thread_local napi_ref JsTypeface::constructor_ = nullptr;
29 const std::string CLASS_NAME = "Typeface";
30 const std::string G_SYSTEM_FONT_DIR = "/system/fonts";
Init(napi_env env,napi_value exportObj)31 napi_value JsTypeface::Init(napi_env env, napi_value exportObj)
32 {
33 napi_property_descriptor properties[] = {
34 DECLARE_NAPI_FUNCTION("getFamilyName", JsTypeface::GetFamilyName),
35 DECLARE_NAPI_FUNCTION("makeFromCurrent", JsTypeface::MakeFromCurrent),
36 DECLARE_NAPI_STATIC_FUNCTION("makeFromFile", JsTypeface::MakeFromFile),
37 DECLARE_NAPI_STATIC_FUNCTION("makeFromFileWithArguments", JsTypeface::MakeFromFileWithArguments),
38 DECLARE_NAPI_STATIC_FUNCTION("makeFromRawFile", JsTypeface::MakeFromRawFile),
39 DECLARE_NAPI_STATIC_FUNCTION("makeFromRawFileWithArguments", JsTypeface::MakeFromRawFileWithArguments),
40 };
41
42 napi_value constructor = nullptr;
43 napi_status status = napi_define_class(env, CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Constructor, nullptr,
44 sizeof(properties) / sizeof(properties[0]), properties, &constructor);
45 if (status != napi_ok) {
46 ROSEN_LOGE("Failed to define Typeface class");
47 return nullptr;
48 }
49
50 status = napi_create_reference(env, constructor, 1, &constructor_);
51 if (status != napi_ok) {
52 ROSEN_LOGE("Failed to create reference of constructor");
53 return nullptr;
54 }
55
56 status = napi_set_named_property(env, exportObj, CLASS_NAME.c_str(), constructor);
57 if (status != napi_ok) {
58 ROSEN_LOGE("Failed to set constructor");
59 return nullptr;
60 }
61
62 return exportObj;
63 }
64
Constructor(napi_env env,napi_callback_info info)65 napi_value JsTypeface::Constructor(napi_env env, napi_callback_info info)
66 {
67 size_t argCount = 0;
68 napi_value jsThis = nullptr;
69 napi_status status = napi_get_cb_info(env, info, &argCount, nullptr, &jsThis, nullptr);
70 if (status != napi_ok) {
71 ROSEN_LOGE("failed to napi_get_cb_info");
72 return nullptr;
73 }
74
75 JsTypeface *jsTypeface = new JsTypeface(JsTypeface::GetZhCnTypeface());
76
77 status = napi_wrap(env, jsThis, jsTypeface, JsTypeface::Destructor, nullptr, nullptr);
78 if (status != napi_ok) {
79 delete jsTypeface;
80 ROSEN_LOGE("Failed to wrap native instance");
81 return nullptr;
82 }
83 return jsThis;
84 }
85
Destructor(napi_env env,void * nativeObject,void * finalize)86 void JsTypeface::Destructor(napi_env env, void *nativeObject, void *finalize)
87 {
88 (void)finalize;
89 if (nativeObject != nullptr) {
90 JsTypeface *napi = reinterpret_cast<JsTypeface *>(nativeObject);
91 delete napi;
92 }
93 }
94
~JsTypeface()95 JsTypeface::~JsTypeface()
96 {
97 m_typeface = nullptr;
98 }
99
CreateJsTypeface(napi_env env,const std::shared_ptr<Typeface> typeface)100 napi_value JsTypeface::CreateJsTypeface(napi_env env, const std::shared_ptr<Typeface> typeface)
101 {
102 napi_value constructor = nullptr;
103 napi_status status = napi_get_reference_value(env, constructor_, &constructor);
104 if (status != napi_ok) {
105 ROSEN_LOGE("JsTypeface::CreateJsTypeface get reference value failed!");
106 return nullptr;
107 }
108 napi_value result = nullptr;
109 napi_create_object(env, &result);
110 if (result == nullptr) {
111 ROSEN_LOGE("JsTypeface::CreateJsTypeface create object failed!");
112 return nullptr;
113 }
114 JsTypeface* jsTypeface = new JsTypeface(typeface);
115 status = napi_wrap(env, result, jsTypeface, JsTypeface::Destructor, nullptr, nullptr);
116 if (status != napi_ok) {
117 delete jsTypeface;
118 ROSEN_LOGE("JsTypeface::CreateJsTypeface failed to wrap native instance");
119 return nullptr;
120 }
121 napi_property_descriptor resultFuncs[] = {
122 DECLARE_NAPI_FUNCTION("getFamilyName", JsTypeface::GetFamilyName),
123 DECLARE_NAPI_FUNCTION("makeFromCurrent", JsTypeface::MakeFromCurrent),
124 };
125 napi_define_properties(env, result, sizeof(resultFuncs) / sizeof(resultFuncs[0]), resultFuncs);
126 return result;
127 }
128
LoadZhCnTypeface()129 std::shared_ptr<Typeface> LoadZhCnTypeface()
130 {
131 std::shared_ptr<Typeface> typeface = Typeface::MakeFromFile(JsTypeface::ZH_CN_TTF);
132 if (typeface == nullptr) {
133 typeface = Typeface::MakeDefault();
134 }
135 return typeface;
136 }
137
GetZhCnTypeface()138 std::shared_ptr<Typeface> JsTypeface::GetZhCnTypeface()
139 {
140 static std::shared_ptr<Typeface> zhCnTypeface = LoadZhCnTypeface();
141 return zhCnTypeface;
142 }
143
GetTypeface()144 std::shared_ptr<Typeface> JsTypeface::GetTypeface()
145 {
146 return m_typeface;
147 }
148
GetFamilyName(napi_env env,napi_callback_info info)149 napi_value JsTypeface::GetFamilyName(napi_env env, napi_callback_info info)
150 {
151 JsTypeface* me = CheckParamsAndGetThis<JsTypeface>(env, info);
152 return (me != nullptr) ? me->OnGetFamilyName(env, info) : nullptr;
153 }
154
OnGetFamilyName(napi_env env,napi_callback_info info)155 napi_value JsTypeface::OnGetFamilyName(napi_env env, napi_callback_info info)
156 {
157 if (m_typeface == nullptr) {
158 ROSEN_LOGE("[NAPI]typeface is null");
159 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
160 }
161
162 auto name = m_typeface->GetFamilyName();
163 return GetStringAndConvertToJsValue(env, name);
164 }
165
ConvertTypefaceToJsValue(napi_env env,JsTypeface * typeface)166 napi_value JsTypeface::ConvertTypefaceToJsValue(napi_env env, JsTypeface* typeface)
167 {
168 napi_value jsObj = nullptr;
169 napi_create_object(env, &jsObj);
170 if (jsObj == nullptr) {
171 ROSEN_LOGE("JsTypeface::ConvertTypefaceToJsValue Create Typeface failed!");
172 return nullptr;
173 }
174 napi_status status = napi_wrap(env, jsObj, typeface, JsTypeface::Destructor, nullptr, nullptr);
175 if (status != napi_ok) {
176 ROSEN_LOGE("JsTypeface::ConvertTypefaceToJsValue failed to wrap native instance");
177 return nullptr;
178 }
179 napi_property_descriptor resultFuncs[] = {
180 DECLARE_NAPI_FUNCTION("getFamilyName", JsTypeface::GetFamilyName),
181 DECLARE_NAPI_FUNCTION("makeFromCurrent", JsTypeface::MakeFromCurrent),
182 };
183 napi_define_properties(env, jsObj, sizeof(resultFuncs) / sizeof(resultFuncs[0]), resultFuncs);
184 return jsObj;
185 }
186
MakeFromCurrent(napi_env env,napi_callback_info info)187 napi_value JsTypeface::MakeFromCurrent(napi_env env, napi_callback_info info)
188 {
189 JsTypeface* me = CheckParamsAndGetThis<JsTypeface>(env, info);
190 return (me != nullptr) ? me->OnMakeFromCurrent(env, info) : nullptr;
191 }
192
OnMakeFromCurrent(napi_env env,napi_callback_info info)193 napi_value JsTypeface::OnMakeFromCurrent(napi_env env, napi_callback_info info)
194 {
195 if (m_typeface == nullptr) {
196 ROSEN_LOGE("[NAPI]typeface is null");
197 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
198 }
199 napi_value argv[ARGC_ONE] = {nullptr};
200 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
201 JsTypeFaceArguments* jsTypefaceArguments = nullptr;
202 GET_UNWRAP_PARAM(ARGC_ZERO, jsTypefaceArguments);
203
204 FontArguments fontArguments;
205 JsTypeFaceArguments::ConvertToFontArguments(jsTypefaceArguments->GetTypeFaceArgumentsHelper(), fontArguments);
206 auto rawTypeface = m_typeface->MakeClone(fontArguments);
207 if (rawTypeface == nullptr) {
208 ROSEN_LOGE("JsTypeface::OnMakeFromCurrent create rawTypeface failed.");
209 return nullptr;
210 }
211
212 auto typeface = new JsTypeface(rawTypeface);
213 if (rawTypeface->IsCustomTypeface() && Drawing::Typeface::GetTypefaceRegisterCallBack() != nullptr &&
214 !Drawing::Typeface::GetTypefaceRegisterCallBack()(rawTypeface)) {
215 delete typeface;
216 ROSEN_LOGE("JsTypeface::OnMakeFromCurrent MakeRegister Typeface failed.");
217 return nullptr;
218 }
219
220 napi_value jsObj = ConvertTypefaceToJsValue(env, typeface);
221 if (jsObj == nullptr) {
222 delete typeface;
223 ROSEN_LOGE("JsTypeface::OnMakeFromCurrent Convert typeface to napivalue failed.");
224 return nullptr;
225 }
226 return jsObj;
227 }
228
MakeFromFile(napi_env env,napi_callback_info info)229 napi_value JsTypeface::MakeFromFile(napi_env env, napi_callback_info info)
230 {
231 napi_value argv[ARGC_ONE] = {nullptr};
232 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_ONE);
233
234 std::string text = "";
235 GET_JSVALUE_PARAM(ARGC_ZERO, text);
236
237 auto rawTypeface = Typeface::MakeFromFile(text.c_str());
238 if (rawTypeface == nullptr) {
239 ROSEN_LOGE("JsTypeface::MakeFromFile create rawTypeface failed!");
240 return nullptr;
241 }
242 auto typeface = new JsTypeface(rawTypeface);
243 std::string pathStr(text);
244 if (pathStr.substr(0, G_SYSTEM_FONT_DIR.length()) != G_SYSTEM_FONT_DIR &&
245 Drawing::Typeface::GetTypefaceRegisterCallBack() != nullptr) {
246 bool ret = Drawing::Typeface::GetTypefaceRegisterCallBack()(rawTypeface);
247 if (!ret) {
248 delete typeface;
249 ROSEN_LOGE("JsTypeface::MakeFromFile MakeRegister Typeface failed!");
250 return nullptr;
251 }
252 }
253
254 napi_value jsObj = ConvertTypefaceToJsValue(env, typeface);
255 if (jsObj == nullptr) {
256 delete typeface;
257 ROSEN_LOGE("JsTypeface::MakeFromFile Convert typeface to napivalue failed!");
258 return nullptr;
259 }
260 return jsObj;
261 }
262
MakeFromFileWithArguments(napi_env env,napi_callback_info info)263 napi_value JsTypeface::MakeFromFileWithArguments(napi_env env, napi_callback_info info)
264 {
265 napi_value argv[ARGC_TWO] = {nullptr};
266 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_TWO);
267
268 std::string text = "";
269 GET_JSVALUE_PARAM(ARGC_ZERO, text);
270
271 JsTypeFaceArguments* jsTypefaceArguments = nullptr;
272 GET_UNWRAP_PARAM(ARGC_ONE, jsTypefaceArguments);
273 FontArguments fontArguments;
274 JsTypeFaceArguments::ConvertToFontArguments(jsTypefaceArguments->GetTypeFaceArgumentsHelper(), fontArguments);
275
276 auto rawTypeface = Typeface::MakeFromFile(text.c_str(), fontArguments);
277 if (rawTypeface == nullptr) {
278 ROSEN_LOGE("JsTypeface::MakeFromFile create rawTypeface failed.");
279 return nullptr;
280 }
281 auto typeface = new JsTypeface(rawTypeface);
282 std::string pathStr(text);
283 if (pathStr.substr(0, G_SYSTEM_FONT_DIR.length()) != G_SYSTEM_FONT_DIR &&
284 Drawing::Typeface::GetTypefaceRegisterCallBack() != nullptr &&
285 !Drawing::Typeface::GetTypefaceRegisterCallBack()(rawTypeface)) {
286 delete typeface;
287 ROSEN_LOGE("JsTypeface:: MakeFromFile MakeRegister Typeface failed!");
288 return nullptr;
289 }
290
291 napi_value jsObj = ConvertTypefaceToJsValue(env, typeface);
292 if (jsObj == nullptr) {
293 delete typeface;
294 ROSEN_LOGE("JsTypeface:: MakeFromFile Convert typeface to napivalue failed.");
295 return nullptr;
296 }
297 return jsObj;
298 }
299
MakeFromRawFile(napi_env env,napi_callback_info info)300 napi_value JsTypeface::MakeFromRawFile(napi_env env, napi_callback_info info)
301 {
302 #if defined(ROSEN_OHOS) || defined(ROSEN_ARKUI_X)
303 size_t argc = ARGC_ONE;
304 napi_value argv[ARGC_ONE] = {nullptr};
305 CHECK_PARAM_NUMBER_WITH_OPTIONAL_PARAMS(argv, argc, ARGC_ONE, ARGC_ONE);
306
307 std::unique_ptr<uint8_t[]> rawFileArrayBuffer;
308 size_t rawFileArrayBufferSize = 0;
309 ResourceInfo resourceInfo;
310 if (!JsTool::GetResourceInfo(env, argv[ARGC_ZERO], resourceInfo) ||
311 !JsTool::GetResourceRawFileDataBuffer(std::move(rawFileArrayBuffer), rawFileArrayBufferSize, resourceInfo)) {
312 ROSEN_LOGE("JsTypeface::MakeFromRawFile get rawfilebuffer failed!");
313 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
314 }
315
316 auto memory_stream = std::make_unique<MemoryStream>((rawFileArrayBuffer.get()), rawFileArrayBufferSize, true);
317 auto rawTypeface = Typeface::MakeFromStream(std::move(memory_stream));
318 if (rawTypeface == nullptr) {
319 ROSEN_LOGE("JsTypeface::MakeFromRawFile Create rawTypeface failed!");
320 return nullptr;
321 }
322 auto typeface = new JsTypeface(rawTypeface);
323 if (Drawing::Typeface::GetTypefaceRegisterCallBack() != nullptr) {
324 bool ret = Drawing::Typeface::GetTypefaceRegisterCallBack()(rawTypeface);
325 if (!ret) {
326 delete typeface;
327 ROSEN_LOGE("JsTypeface::MakeFromRawFile MakeRegister Typeface failed!");
328 return nullptr;
329 }
330 }
331
332 napi_value jsObj = ConvertTypefaceToJsValue(env, typeface);
333 if (jsObj == nullptr) {
334 delete typeface;
335 ROSEN_LOGE("JsTypeface::MakeFromRawFile Convert typeface to napivalue failed!");
336 return nullptr;
337 }
338 return jsObj;
339 #else
340 return nullptr;
341 #endif
342 }
343
MakeFromRawFileWithArguments(napi_env env,napi_callback_info info)344 napi_value JsTypeface::MakeFromRawFileWithArguments(napi_env env, napi_callback_info info)
345 {
346 #if defined(ROSEN_OHOS) || defined(ROSEN_ARKUI_X)
347 napi_value argv[ARGC_TWO] = {nullptr};
348 CHECK_PARAM_NUMBER_WITHOUT_OPTIONAL_PARAMS(argv, ARGC_TWO);
349
350 std::unique_ptr<uint8_t[]> rawFileArrayBuffer;
351 size_t rawFileArrayBufferSize = 0;
352 ResourceInfo resourceInfo;
353 if (!JsTool::GetResourceInfo(env, argv[ARGC_ZERO], resourceInfo) ||
354 !JsTool::GetResourceRawFileDataBuffer(std::move(rawFileArrayBuffer), rawFileArrayBufferSize, resourceInfo)) {
355 ROSEN_LOGE("JsTypeface::MakeFromRawFileWithArguments get rawfilebuffer failed.");
356 return NapiThrowError(env, DrawingErrorCode::ERROR_INVALID_PARAM, "Invalid params.");
357 }
358 auto memory_stream = std::make_unique<MemoryStream> ((rawFileArrayBuffer.get()), rawFileArrayBufferSize, true);
359 JsTypeFaceArguments* jsTypefaceArguments = nullptr;
360 GET_UNWRAP_PARAM(ARGC_ONE, jsTypefaceArguments);
361 FontArguments fontArguments;
362 JsTypeFaceArguments::ConvertToFontArguments(jsTypefaceArguments->GetTypeFaceArgumentsHelper(), fontArguments);
363 auto rawTypeface = Typeface::MakeFromStream(std::move(memory_stream), fontArguments);
364 if (rawTypeface == nullptr) {
365 ROSEN_LOGE("JsTypeface::MakeFromRawFile Create rawTypeface failed.");
366 return nullptr;
367 }
368 auto typeface = new JsTypeface(rawTypeface);
369 if (Drawing::Typeface::GetTypefaceRegisterCallBack() != nullptr) {
370 bool ret = Drawing::Typeface::GetTypefaceRegisterCallBack()(rawTypeface);
371 if (!ret) {
372 delete typeface;
373 ROSEN_LOGE("JsTypeface::MakeFromFile MakeRegister Typeface failed.");
374 return nullptr;
375 }
376 }
377
378 napi_value jsObj = ConvertTypefaceToJsValue(env, typeface);
379 if (jsObj == nullptr) {
380 delete typeface;
381 ROSEN_LOGE("JsTypeface:: MakeFromFile Convert typeface to napivalue failed");
382 return nullptr;
383 }
384 return jsObj;
385 #else
386 return nullptr;
387 #endif
388 }
389 } // namespace Drawing
390 } // namespace OHOS::Rosen