1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "com_android_tools_aapt2_Aapt2Jni.h"
18
19 #include <algorithm>
20 #include <memory>
21 #include <utility>
22 #include <vector>
23
24 #include "android-base/logging.h"
25 #include "ScopedUtfChars.h"
26
27 #include "Diagnostics.h"
28 #include "cmd/Compile.h"
29 #include "cmd/Link.h"
30 #include "util/Util.h"
31
32 using android::StringPiece;
33
34 /*
35 * Converts a java List<String> into C++ vector<ScopedUtfChars>.
36 */
list_to_utfchars(JNIEnv * env,jobject obj)37 static std::vector<ScopedUtfChars> list_to_utfchars(JNIEnv *env, jobject obj) {
38 std::vector<ScopedUtfChars> converted;
39
40 // Call size() method on the list to know how many elements there are.
41 jclass list_cls = env->GetObjectClass(obj);
42 jmethodID size_method_id = env->GetMethodID(list_cls, "size", "()I");
43 CHECK(size_method_id != 0);
44 jint size = env->CallIntMethod(obj, size_method_id);
45 CHECK(size >= 0);
46
47 // Now, iterate all strings in the list
48 // (note: generic erasure means get() return an Object)
49 jmethodID get_method_id = env->GetMethodID(list_cls, "get", "(I)Ljava/lang/Object;");
50 CHECK(get_method_id != 0);
51 for (jint i = 0; i < size; i++) {
52 // Call get(i) to get the string in the ith position.
53 jobject string_obj_uncast = env->CallObjectMethod(obj, get_method_id, i);
54 CHECK(string_obj_uncast != nullptr);
55 jstring string_obj = static_cast<jstring>(string_obj_uncast);
56 converted.push_back(ScopedUtfChars(env, string_obj));
57 }
58
59 return converted;
60 }
61
62 /*
63 * Extracts all StringPiece from the ScopedUtfChars instances.
64 *
65 * The returned pieces can only be used while the original ones have not been
66 * destroyed.
67 */
extract_pieces(const std::vector<ScopedUtfChars> & strings)68 static std::vector<StringPiece> extract_pieces(const std::vector<ScopedUtfChars> &strings) {
69 std::vector<StringPiece> pieces;
70
71 std::for_each(
72 strings.begin(), strings.end(),
73 [&pieces](const ScopedUtfChars &p) { pieces.push_back(p.c_str()); });
74
75 return pieces;
76 }
77
78 class JniDiagnostics : public aapt::IDiagnostics {
79 public:
JniDiagnostics(JNIEnv * env,jobject diagnostics_obj)80 JniDiagnostics(JNIEnv* env, jobject diagnostics_obj)
81 : env_(env), diagnostics_obj_(diagnostics_obj) {
82 mid_ = NULL;
83 }
84
Log(Level level,aapt::DiagMessageActual & actual_msg)85 void Log(Level level, aapt::DiagMessageActual& actual_msg) override {
86 jint level_value;
87 switch (level) {
88 case Level::Error:
89 level_value = 3;
90 break;
91
92 case Level::Warn:
93 level_value = 2;
94 break;
95
96 case Level::Note:
97 level_value = 1;
98 break;
99 }
100 jstring message = env_->NewStringUTF(actual_msg.message.c_str());
101 jstring path = env_->NewStringUTF(actual_msg.source.path.c_str());
102 jlong line = -1;
103 if (actual_msg.source.line) {
104 line = actual_msg.source.line.value();
105 }
106 if (!mid_) {
107 jclass diagnostics_cls = env_->GetObjectClass(diagnostics_obj_);
108 mid_ = env_->GetMethodID(diagnostics_cls, "log", "(ILjava/lang/String;JLjava/lang/String;)V");
109 }
110 env_->CallVoidMethod(diagnostics_obj_, mid_, level_value, path, line, message);
111 }
112
113 private:
114 JNIEnv* env_;
115 jobject diagnostics_obj_;
116 jmethodID mid_;
117 DISALLOW_COPY_AND_ASSIGN(JniDiagnostics);
118 };
119
Java_com_android_tools_aapt2_Aapt2Jni_nativeCompile(JNIEnv * env,jclass aapt_obj,jobject arguments_obj,jobject diagnostics_obj)120 JNIEXPORT jint JNICALL Java_com_android_tools_aapt2_Aapt2Jni_nativeCompile(
121 JNIEnv* env, jclass aapt_obj, jobject arguments_obj, jobject diagnostics_obj) {
122 std::vector<ScopedUtfChars> compile_args_jni =
123 list_to_utfchars(env, arguments_obj);
124 std::vector<StringPiece> compile_args = extract_pieces(compile_args_jni);
125 JniDiagnostics diagnostics(env, diagnostics_obj);
126 return aapt::CompileCommand(&diagnostics).Execute(compile_args, &std::cerr);
127 }
128
Java_com_android_tools_aapt2_Aapt2Jni_nativeLink(JNIEnv * env,jclass aapt_obj,jobject arguments_obj,jobject diagnostics_obj)129 JNIEXPORT jint JNICALL Java_com_android_tools_aapt2_Aapt2Jni_nativeLink(JNIEnv* env,
130 jclass aapt_obj,
131 jobject arguments_obj,
132 jobject diagnostics_obj) {
133 std::vector<ScopedUtfChars> link_args_jni =
134 list_to_utfchars(env, arguments_obj);
135 std::vector<StringPiece> link_args = extract_pieces(link_args_jni);
136 JniDiagnostics diagnostics(env, diagnostics_obj);
137 return aapt::LinkCommand(&diagnostics).Execute(link_args, &std::cerr);
138 }
139
Java_com_android_tools_aapt2_Aapt2Jni_ping(JNIEnv * env,jclass aapt_obj)140 JNIEXPORT void JNICALL Java_com_android_tools_aapt2_Aapt2Jni_ping(
141 JNIEnv *env, jclass aapt_obj) {
142 // This is just a dummy method to see if the library has been loaded.
143 }
144