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 46 static void PrintVersion() { 47 std::cerr << StringPrintf("Android Asset Packaging Tool (aapt) %s:%s", sMajorVersion, 48 sMinorVersion) 49 << std::endl; 50 } 51 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 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 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 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 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
