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 #ifdef _WIN32
18 // clang-format off
19 #include <windows.h>
20 #include <shellapi.h>
21 // clang-format on
22 #endif
23
24 #include <iostream>
25 #include <vector>
26
27 #include "android-base/stringprintf.h"
28 #include "android-base/utf8.h"
29 #include "androidfw/StringPiece.h"
30
31 #include "Diagnostics.h"
32 #include "util/Files.h"
33 #include "util/Util.h"
34
35 using ::android::StringPiece;
36 using ::android::base::StringPrintf;
37
38 namespace aapt {
39
40 // DO NOT UPDATE, this is more of a marketing version.
41 static const char* sMajorVersion = "2";
42
43 // Update minor version whenever a feature or flag is added.
44 static const char* sMinorVersion = "19";
45
PrintVersion()46 static void PrintVersion() {
47 std::cerr << StringPrintf("Android Asset Packaging Tool (aapt) %s:%s", sMajorVersion,
48 sMinorVersion)
49 << std::endl;
50 }
51
PrintUsage()52 static void PrintUsage() {
53 std::cerr << "\nusage: aapt2 [compile|link|dump|diff|optimize|convert|version] ..." << std::endl;
54 }
55
56 extern int Compile(const std::vector<StringPiece>& args, IDiagnostics* diagnostics);
57 extern int Link(const std::vector<StringPiece>& args, IDiagnostics* diagnostics);
58 extern int Dump(const std::vector<StringPiece>& args);
59 extern int Diff(const std::vector<StringPiece>& args);
60 extern int Optimize(const std::vector<StringPiece>& args);
61 extern int Convert(const std::vector<StringPiece>& args);
62
ExecuteCommand(const StringPiece & command,const std::vector<StringPiece> & args,IDiagnostics * diagnostics)63 static int ExecuteCommand(const StringPiece& command, const std::vector<StringPiece>& args,
64 IDiagnostics* diagnostics) {
65 if (command == "compile" || command == "c") {
66 return Compile(args, diagnostics);
67 } else if (command == "link" || command == "l") {
68 return Link(args, diagnostics);
69 } else if (command == "dump" || command == "d") {
70 return Dump(args);
71 } else if (command == "diff") {
72 return Diff(args);
73 } else if (command == "optimize") {
74 return Optimize(args);
75 } else if (command == "convert") {
76 return Convert(args);
77 } else if (command == "version") {
78 PrintVersion();
79 return 0;
80 }
81 diagnostics->Error(DiagMessage() << "unknown command '" << command << "'");
82 return -1;
83 }
84
RunDaemon(IDiagnostics * diagnostics)85 static void RunDaemon(IDiagnostics* diagnostics) {
86 std::cout << "Ready" << std::endl;
87
88 // Run in daemon mode. The first line of input is the command. This can be 'quit' which ends
89 // the daemon mode. Each subsequent line is a single parameter to the command. The end of a
90 // invocation is signaled by providing an empty line. At any point, an EOF signal or the
91 // command 'quit' will end the daemon mode.
92 while (true) {
93 std::vector<std::string> raw_args;
94 for (std::string line; std::getline(std::cin, line) && !line.empty();) {
95 raw_args.push_back(line);
96 }
97
98 if (!std::cin) {
99 break;
100 }
101
102 // An empty command does nothing.
103 if (raw_args.empty()) {
104 continue;
105 }
106
107 if (raw_args[0] == "quit") {
108 break;
109 }
110
111 std::vector<StringPiece> args;
112 args.insert(args.end(), ++raw_args.begin(), raw_args.end());
113 int ret = ExecuteCommand(raw_args[0], args, diagnostics);
114 if (ret != 0) {
115 std::cerr << "Error" << std::endl;
116 }
117 std::cerr << "Done" << std::endl;
118 }
119 std::cout << "Exiting daemon" << std::endl;
120 }
121
122 } // namespace aapt
123
MainImpl(int argc,char ** argv)124 int MainImpl(int argc, char** argv) {
125 if (argc < 2) {
126 std::cerr << "no command specified\n";
127 aapt::PrintUsage();
128 return -1;
129 }
130
131 argv += 1;
132 argc -= 1;
133
134 aapt::StdErrDiagnostics diagnostics;
135
136 // Collect the arguments starting after the program name and command name.
137 std::vector<StringPiece> args;
138 for (int i = 1; i < argc; i++) {
139 args.push_back(argv[i]);
140 }
141
142 const StringPiece command(argv[0]);
143 if (command != "daemon" && command != "m") {
144 // Single execution.
145 const int result = aapt::ExecuteCommand(command, args, &diagnostics);
146 if (result < 0) {
147 aapt::PrintUsage();
148 }
149 return result;
150 }
151
152 aapt::RunDaemon(&diagnostics);
153 return 0;
154 }
155
main(int argc,char ** argv)156 int main(int argc, char** argv) {
157 #ifdef _WIN32
158 LPWSTR* wide_argv = CommandLineToArgvW(GetCommandLineW(), &argc);
159 CHECK(wide_argv != nullptr) << "invalid command line parameters passed to process";
160
161 std::vector<std::string> utf8_args;
162 for (int i = 0; i < argc; i++) {
163 std::string utf8_arg;
164 if (!::android::base::WideToUTF8(wide_argv[i], &utf8_arg)) {
165 std::cerr << "error converting input arguments to UTF-8" << std::endl;
166 return 1;
167 }
168 utf8_args.push_back(std::move(utf8_arg));
169 }
170 LocalFree(wide_argv);
171
172 std::unique_ptr<char* []> utf8_argv(new char*[utf8_args.size()]);
173 for (int i = 0; i < argc; i++) {
174 utf8_argv[i] = const_cast<char*>(utf8_args[i].c_str());
175 }
176 argv = utf8_argv.get();
177 #endif
178 return MainImpl(argc, argv);
179 }
180