{

if(!IsHostADB(hostname.c_str()))

return;

const char *c = hostname.c_str();

c += 4;

index = atoi(c);

c = strchr(c, ':');

if(!c)

{

index = 0;

return;

}

c++;

deviceID = c;

{

if(packageAndActivity.empty())

return "";

int32_t start = 0;

if(packageAndActivity[0] == '/')

start++;

int32_t activitySep = packageAndActivity.find('/', start);

if(activitySep < 0)

return packageAndActivity.substr(start);

return packageAndActivity.substr(start, activitySep - start);

{

if(packageAndActivity.empty())

return "";

int32_t start = 0;

if(packageAndActivity[0] == '/')

start++;

int32_t activitySep = packageAndActivity.find('/', start);

if(activitySep < 0)

return "";

return packageAndActivity.substr(activitySep + 1);

{

if(abiName == "armeabi-v7a")

return ABI::armeabi_v7a;

else if(abiName == "arm64-v8a")

return ABI::arm64_v8a;

else if(abiName == "x86")

return ABI::x86;

else if(abiName == "x86_64")

return ABI::x86_64;

RDCWARN("Unknown or unsupported ABI %s", abiName.c_str());

return ABI::unknown;

{

switch(abi)

{

case ABI::arm64_v8a: return "arm64";

case ABI::armeabi_v7a: return "arm32";

case ABI::x86_64: return "x64";

case ABI::x86: return "x86";

default: break;

}

return "unsupported";

{

rdcstr adbAbi = adbExecCommand(deviceID, "shell getprop ro.product.cpu.abi").strStdout.trimmed();

// these returned lists should be such that the first entry is the 'lowest command denominator' -

// typically 32-bit.

switch(GetABI(adbAbi))

{

case ABI::arm64_v8a: return {ABI::armeabi_v7a, ABI::arm64_v8a};

case ABI::armeabi_v7a: return {ABI::armeabi_v7a};

case ABI::x86_64: return {ABI::x86, ABI::x86_64};

case ABI::x86: return {ABI::x86};

default: break;

}

return {};

{

rdcstr pkgPath = adbExecCommand(deviceID, "shell pm path " + packageName).strStdout.trimmed();

// if there are multiple slices, the path will be returned on many lines. Take only the first

// line, assuming all of the apks are in the same directory

if(pkgPath.find("\n") >= 0)

{

rdcarray<rdcstr> lines;

split(pkgPath, lines, '\n');

pkgPath = lines[0].trimmed();

}

if(pkgPath.empty() || pkgPath.find("package:") != 0 || pkgPath.find("base.apk") == -1)

return pkgPath;

pkgPath.erase(0, strlen("package:"));

pkgPath.erase(pkgPath.size() - strlen("base.apk"), ~0U);

return pkgPath;

{

rdcstr api =

Android::adbExecCommand(deviceID, "shell getprop ro.build.version.sdk").strStdout.trimmed();

int apiVersion = atoi(api.c_str());

// SDK 23 == Android 6.0, our minimum spec. Only fail if we did parse an SDK string, in case some

// Android devices don't support the query - we assume they are new enough.

if(apiVersion >= 0 && apiVersion < 23)

{

RDCWARN("Device '%s' is on api version %d which is not supported",

GetFriendlyName(deviceID).c_str(), apiVersion);

return false;

}

return true;

{

rdcstr api =

Android::adbExecCommand(deviceID, "shell getprop ro.build.version.sdk").strStdout.trimmed();

int apiVersion = atoi(api.c_str());

if(apiVersion >= 30)

return "media/";

return "data/";

{

rdcstr api =

Android::adbExecCommand(deviceID, "shell getprop ro.build.version.sdk").strStdout.trimmed();

int apiVersion = atoi(api.c_str());

// SDK 29 == Android 10.0, the first version that included layering

if(apiVersion >= 29)

return true;

return false;

{

RDCLOG("Checking installed ABI for %s", packageName.c_str());

rdcstr abi;

rdcstr dump = adbExecCommand(deviceID, "shell pm dump " + packageName).strStdout;

if(dump.empty())

RDCERR("Unable to pm dump %s", packageName.c_str());

// Walk through the output and look for primaryCpuAbi

rdcstr prefix = "primaryCpuAbi=";

int offset = dump.find("primaryCpuAbi=");

if(offset >= 0)

{

offset = dump.find('=', offset) + 1;

int newline = dump.find('\n', offset);

if(newline >= 0)

abi = dump.substr(offset, newline - offset).trimmed();

}

if(abi.empty())

RDCERR("Unable to determine installed abi for: %s", packageName.c_str());

return abi;

{

// run adb root now, so we hit any disconnection that we're going to before trying to connect.

// If we can't be root, this is cheap, if we're already root, this is cheap, if we can be root

// and this changes us it will block only the first time - and we expect this function to be

// slow-ish.

//

// We do this here so that we sneakily take advantage of the above caching - otherwise we spam adb

// root commands into the log

Android::adbExecCommand(deviceID, "root");

rdcstr manuf =

Android::adbExecCommand(deviceID, "shell getprop ro.product.manufacturer").strStdout.trimmed();

rdcstr model =

Android::adbExecCommand(deviceID, "shell getprop ro.product.model").strStdout.trimmed();

rdcstr combined;

if(manuf.empty() && model.empty())

combined = "";

else if(manuf.empty() && !model.empty())

combined = model;

else if(!manuf.empty() && model.empty())

combined = manuf + " device";

else if(!manuf.empty() && !model.empty())

combined = manuf + " " + model;

return combined;

{

RDCLOG("Checking for root access on %s", deviceID.c_str());

// Try switching adb to root and check a few indicators for success

// Nothing will fall over if we get a false positive here, it just enables

// additional methods of getting things set up.

Process::ProcessResult result = adbExecCommand(deviceID, "root");

rdcstr whoami = adbExecCommand(deviceID, "shell whoami").strStdout.trimmed();

if(whoami == "root")

return true;

rdcstr checksu =

adbExecCommand(deviceID, "shell test -e /system/xbin/su && echo found").strStdout.trimmed();

if(checksu == "found")

return true;

return false;

{

int needleOffset = haystack.find(needle);

if(needleOffset == -1)

return rdcstr();

int nextLine = haystack.find('\n', needleOffset + 1);

return haystack.substr(needleOffset, nextLine == -1 ? ~0U : size_t(nextLine - needleOffset));

{

RDCLOG("Checking that APK is debuggable");

rdcstr info = adbExecCommand(deviceID, "shell dumpsys package " + packageName).strStdout;

rdcstr pkgFlags = GetFirstMatchingLine(info, "pkgFlags=[");

if(pkgFlags == "")

{

RDCERR("Couldn't get pkgFlags from adb");

return false;

}

return pkgFlags.contains("DEBUGGABLE");

{

#if ENABLED(RDOC_ANDROID)

static uint64_t freq = (uint64_t)Timing::GetTickFrequency();

const uint64_t timeMS = uint64_t(Timing::GetTick() / freq);

static uint64_t prevTimeMS = 0;

// don't spam more than once every 100ms to avoid saturating our log

if(timeMS > prevTimeMS + 100)

{

prevTimeMS = timeMS;

OSUtility::WriteOutput(OSUtility::Output_DebugMon,

StringFormat::Fmt("__rdoc_internal_android_logcat %llu", timeMS).c_str());

}

#endif

{

time_t timestamp = 0;

uint32_t pid = 0;

LogType logtype = LogType::Comment;

rdcstr filename;

uint32_t line_number = 0;

rdcstr message;

bool parse(const rdcstr &line)

{

#define EXPECT_CHAR(c) \

if(idx >= line.length() || line[idx] != c) \

return false; \

idx++;

// Parse out mostly our own log files, but also output that looks like crash callstacks

//

// Example lines:

//

// clang-format off

//

// 0 1 2 3 4 5 6 7 8 9 10

// 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456

// I/renderdoc( 1234): @1234567812345678@ RDOC 001234: [01:02:03] filename.cpp( 123) - Log - Hello

//

// F/libc (11519): Fatal signal 11 (SIGSEGV), code 1, fault addr 0x4 in tid 11618 (FooBar), pid 11519 (blah)

// F/DEBUG (12061): backtrace:

// F/DEBUG (12061): #00 pc 000485ec /system/lib/libc.so (pthread_mutex_lock+1)

// F/DEBUG (12061): #01 pc 00137449 /data/app/org.renderdoc.renderdoccmd.arm32==/lib/arm/libVkLayer_GLES_RenderDoc.so

// F/DEBUG (12061): #02 pc 0013bbf1 /data/app/org.renderdoc.renderdoccmd.arm32==/lib/arm/libVkLayer_GLES_RenderDoc.so

//

// clang-format on

//

size_t idx = 0;

// too short - minimum is 22 for prefix. Could be longer if PID is over 5 digits

// saves on length checks below

if(line.length() <= 20)

return false;

// skip past priority character

idx++;

EXPECT_CHAR('/');

// we assume that the logcat filters have worked, so ignore the logcat tag here. Just check if

// it's ours or not

bool ownLog = !strncmp(&line[idx], "renderdoc", 9);

while(idx < line.length() && line[idx] != '(')

idx++;

size_t tagEnd = idx;

EXPECT_CHAR('(');

// skip spaces

while(idx < line.length() && isspace(line[idx]))

idx++;

// process this PID field - we'll override it with our own if this is one of our logs

pid = 0;

while(idx < line.length() && isdigit(line[idx]))

{

pid *= 10;

pid += int(line[idx] - '0');

idx++;

}

EXPECT_CHAR(')');

EXPECT_CHAR(':');

EXPECT_CHAR(' ');

if(!ownLog)

{

// don't know anything more about the format, this whole thing is the message.

message = line.substr(idx);

// use current host time, it's not accurate but it's close enough.

timestamp = Timing::GetUTCTime();

filename = line.substr(2, tagEnd - 2);

line_number = 0;

logtype = LogType::Comment;

switch(line[0])

{

case 'V': // VERBOSE

case 'D': // DEBUG

logtype = LogType::Debug;

break;

case 'I': // INFO

logtype = LogType::Comment;

break;

case 'W': // WARN

logtype = LogType::Warning;

break;

case 'E': // ERROR

logtype = LogType::Error;

break;

case 'F': // FATAL

logtype = LogType::Fatal;

break;

case 'S': // SILENT

default: logtype = LogType::Comment; break;

}

// remove any padding spaces

while(!filename.empty() && isspace(filename.back()))

filename.pop_back();

// if adb gave us DOS newlines, remove the \r

if(message.back() == '\r')

message.pop_back();

// ignore these libc spam messages

if(message.contains("Access denied finding property"))

return false;

return true;

}

// skip past digits and '@', this field is only so that we don't ever get duplicates in the

// output even if the same message is printed

while(idx < line.length() && (line[idx] == '@' || isalnum(line[idx])))

idx++;

EXPECT_CHAR(' ');

// should be at least 64 more characters

if(idx + 64 > line.length())

return false;

if(strncmp(&line[idx], "RDOC ", 5) != 0)

return false;

idx += 5;

pid = 0;

while(idx < line.length() && isdigit(line[idx]))

{

pid *= 10;

pid += int(line[idx] - '0');

idx++;

}

EXPECT_CHAR(':');

EXPECT_CHAR(' ');

EXPECT_CHAR('[');

// expect HH:MM:SS

if(idx + 8 >= line.length())

return false;

// we only need the time part, so just take it from the epoch

uint32_t h = 0, m = 0, s = 0;

h = int(line[idx + 0] - '0') * 10 + int(line[idx + 1] - '0');

m = int(line[idx + 3] - '0') * 10 + int(line[idx + 4] - '0');

s = int(line[idx + 6] - '0') * 10 + int(line[idx + 7] - '0');

if(line[idx + 2] != ':' || line[idx + 5] != ':')

return false;

timestamp = (h * 60 + m) * 60 + s;

idx += 8;

EXPECT_CHAR(']');

while(idx < line.length() && line[idx] != '(')

{

filename.push_back(line[idx]);

idx++;

}

// strip spaces

filename.trim();

if(filename.empty())

return false;

EXPECT_CHAR('(');

while(idx < line.length() && isspace(line[idx]))

idx++;

line_number = 0;

while(idx < line.length() && isdigit(line[idx]))

{

line_number *= 10;

line_number += int(line[idx] - '0');

idx++;

}

EXPECT_CHAR(')');

EXPECT_CHAR(' ');

EXPECT_CHAR('-');

EXPECT_CHAR(' ');

rdcstr logtype_str;

while(idx < line.length() && line[idx] != '-')

{

logtype_str.push_back(line[idx]);

idx++;

}

logtype_str.trim();

if(logtype_str == "Debug")

logtype = LogType::Debug;

else if(logtype_str == "Log")

logtype = LogType::Comment;

else if(logtype_str == "Warning")

logtype = LogType::Warning;

else if(logtype_str == "Error")

logtype = LogType::Error;

else if(logtype_str == "Fatal")

logtype = LogType::Fatal;

else

return false;

EXPECT_CHAR('-');

EXPECT_CHAR(' ');

if(idx >= line.length())

return false;

message = line.substr(idx);

// if adb gave us DOS newlines, remove the \r

if(message.back() == '\r')

message.pop_back();

#undef EXPECT_CHAR

return true;

}

{

SCOPED_LOCK(lock);

finishTime = Timing::GetUTCTime();

SelfDelete();

{

// adb is extremely unreliable, so although it supposedly contains functionality to filter for

// everything after a certain timestamp, this can actually drop messages. Instead we just always

// grab the last 750 lines and hope that the device doesn't ever peak over 1 line per millisecond

// such that we'd miss something. Note another joy of adb - the line count is applied *before*

// the filter, so if something else spams 1000 lines we won't see our own.

const uint32_t lineBacklog = 750;

// logcat

// -t N // always the last N messages, and (implied -d) stop after doing so

// -v brief // print the 'brief' format

// -s // silence everything as a default

// renderdoc:* // print logcats from our tag.

// libc:* // or from libc (prints crash messages)

// DEBUG:* // or from DEBUG (prints crash messages)

//

// This gives us all messages from renderdoc since the last timestamp.

rdcstr command =

StringFormat::Fmt("logcat -t %u -v brief -s renderdoc:* libc:* DEBUG:*", lineBacklog);

rdcstr logcat = Android::adbExecCommand(deviceID, command, ".", true).strStdout.trimmed();

rdcarray<rdcstr> lines;

split(logcat, lines, '\n');

// remove \n from any lines right now to prevent it breaking further processing

for(rdcstr &line : lines)

if(!line.empty() && line.back() == '\r')

line.pop_back();

// only do any processing if we had a line last time that we know to start from.

if(!lastLogcatLine.empty())

{

int idx = lines.indexOf(lastLogcatLine);

if(idx >= 0)

{

// remove everything up to and including that line

lines.erase(0, idx + 1);

}

else

{

RDCWARN("Couldn't find last line. Potentially missed logcat messages.");

}

for(const rdcstr &line : lines)

{

LogLine logline;

if(logline.parse(line))

{

rdclog_direct(logline.timestamp, logline.pid, logline.logtype, "ADRD",

logline.filename.c_str(), logline.line_number, "%s", logline.message.c_str());

rdclog_flush();

}

}

}

// store the last line (if we have one) to search for and start from next time

if(!lines.empty())

lastLogcatLine = lines.back();

{

BEGIN_ENUM_STRINGISE(Android::ABI);

{

STRINGISE_ENUM_CLASS(unknown);

STRINGISE_ENUM_CLASS(armeabi_v7a);

STRINGISE_ENUM_CLASS(arm64_v8a);

STRINGISE_ENUM_CLASS(x86);

STRINGISE_ENUM_CLASS(x86_64);

}

END_ENUM_STRINGISE();