• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/env python
2
3r'''
4 Copyright (C) 2010 The Android Open Source Project
5 Copyright (C) 2012 Ray Donnelly <mingw.android@gmail.com>
6
7 Licensed under the Apache License, Version 2.0 (the "License");
8 you may not use this file except in compliance with the License.
9 You may obtain a copy of the License at
10
11      http://www.apache.org/licenses/LICENSE-2.0
12
13 Unless required by applicable law or agreed to in writing, software
14 distributed under the License is distributed on an "AS IS" BASIS,
15 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 See the License for the specific language governing permissions and
17 limitations under the License.
18
19
20 This wrapper script is used to launch a native debugging session
21 on a given NDK application. The application must be debuggable, i.e.
22 its android:debuggable attribute must be set to 'true' in the
23 <application> element of its manifest.
24
25 See docs/NDK-GDB.TXT for usage description. Essentially, you just
26 need to launch ndk-gdb-py from your application project directory
27 after doing ndk-build && ant debug && \
28  adb install && <start-application-on-device>
29'''
30
31import sys, os, platform, argparse, subprocess, types
32import xml.etree.cElementTree as ElementTree
33import shutil, time
34from threading import Thread
35try:
36    from Queue import Queue, Empty
37except ImportError:
38    from queue import Queue, Empty  # python 3.x
39
40def find_program(program, extra_paths = []):
41    ''' extra_paths are searched before PATH '''
42    PATHS = extra_paths+os.environ['PATH'].replace('"','').split(os.pathsep)
43    exts = ['']
44    if sys.platform.startswith('win'):
45        exts += ['.exe', '.bat', '.cmd']
46    for path in PATHS:
47        if os.path.isdir(path):
48            for ext in exts:
49                full = path + os.sep + program + ext
50                if os.path.isfile(full):
51                    return True, full
52    return False, None
53
54def ndk_bin_path(ndk):
55    '''
56    Return the prebuilt bin path for the host OS.
57
58    If Python executable is the NDK-prebuilt one (it should be)
59    then use the location of the executable as the first guess.
60    We take the grand-parent foldername and then ensure that it
61    starts with one of 'linux', 'darwin' or 'windows'.
62
63    If this is not the case, then we're using some other Python
64    and fall-back to using platform.platform() and sys.maxsize.
65    '''
66
67    try:
68        ndk_host = os.path.basename(
69                    os.path.dirname(
70                     os.path.dirname(sys.executable)))
71    except:
72        ndk_host = ''
73    # NDK-prebuilt Python?
74    if (not ndk_host.startswith('linux') and
75        not ndk_host.startswith('darwin') and
76        not ndk_host.startswith('windows')):
77        is64bit = True if sys.maxsize > 2**32 else False
78        if platform.platform().startswith('Linux'):
79            ndk_host = 'linux%s' % ('-x86_64' if is64bit else '-x86')
80        elif platform.platform().startswith('Darwin'):
81            ndk_host = 'darwin%s' % ('-x86_64' if is64bit else '-x86')
82        elif platform.platform().startswith('Windows'):
83            ndk_host = 'windows%s' % ('-x86_64' if is64bit else '')
84        else:
85            ndk_host = 'UNKNOWN'
86    return ndk+os.sep+'prebuilt'+os.sep+ndk_host+os.sep+'bin'
87
88VERBOSE = False
89PROJECT = None
90ADB_CMD = None
91GNUMAKE_CMD = None
92JDB_CMD = None
93# Extra arguments passed to the NDK build system when
94# querying it.
95GNUMAKE_FLAGS = []
96
97OPTION_FORCE = None
98OPTION_EXEC = None
99OPTION_START = None
100OPTION_LAUNCH = None
101OPTION_LAUNCH_LIST = None
102OPTION_TUI = None
103OPTION_WAIT = ['-D']
104OPTION_STDCXXPYPR = None
105
106PYPRPR_BASE = sys.prefix + '/share/pretty-printers/'
107PYPRPR_GNUSTDCXX_BASE = PYPRPR_BASE + 'libstdcxx/'
108
109DEBUG_PORT = 5039
110JDB_PORT = 65534
111
112# Name of the manifest file
113MANIFEST = 'AndroidManifest.xml'
114
115# Delay in seconds between launching the activity and attaching gdbserver on it.
116# This is needed because there is no way to know when the activity has really
117# started, and sometimes this takes a few seconds.
118#
119DELAY = 2.0
120NDK = os.path.abspath(os.path.dirname(sys.argv[0])).replace('\\','/')
121DEVICE_SERIAL = ''
122ADB_FLAGS = ''
123
124def log(string):
125    global VERBOSE
126    if VERBOSE:
127        print(string)
128
129def error(string, errcode=1):
130    print('ERROR: %s' % (string))
131    exit(errcode)
132
133def handle_args():
134    global VERBOSE, DEBUG_PORT, DELAY, DEVICE_SERIAL
135    global GNUMAKE_CMD, GNUMAKE_FLAGS
136    global ADB_CMD, ADB_FLAGS
137    global JDB_CMD
138    global PROJECT, NDK
139    global OPTION_START, OPTION_LAUNCH, OPTION_LAUNCH_LIST
140    global OPTION_FORCE, OPTION_EXEC, OPTION_TUI, OPTION_WAIT
141    global OPTION_STDCXXPYPR
142    global PYPRPR_GNUSTDCXX_BASE
143
144    parser = argparse.ArgumentParser(description='''
145Setup a gdb debugging session for your Android NDK application.
146Read ''' + NDK + '''/docs/NDK-GDB.html for complete usage instructions.''',
147    formatter_class=argparse.RawTextHelpFormatter)
148
149    parser.add_argument( '--verbose',
150                         help='Enable verbose mode', action='store_true', dest='verbose')
151
152    parser.add_argument( '--force',
153                         help='Kill existing debug session if it exists',
154                         action='store_true')
155
156    parser.add_argument( '--start',
157                         help='Launch application instead of attaching to existing one',
158                         action='store_true')
159
160    parser.add_argument( '--launch',
161                         help='Same as --start, but specify activity name (see below)',
162                         dest='launch_name', nargs=1)
163
164    parser.add_argument( '--launch-list',
165                         help='List all launchable activity names from manifest',
166                         action='store_true')
167
168    parser.add_argument( '--delay',
169                         help='Delay in seconds between activity start and gdbserver attach',
170                         type=float, default=DELAY,
171                         dest='delay')
172
173    parser.add_argument( '-p', '--project',
174                         help='Specify application project path',
175                         dest='project')
176
177    parser.add_argument( '--port',
178                         help='Use tcp:localhost:<DEBUG_PORT> to communicate with gdbserver',
179                         type=int, default=DEBUG_PORT,
180                         dest='debug_port')
181
182    parser.add_argument( '-x', '--exec',
183                         help='Execute gdb initialization commands in <EXEC_FILE> after connection',
184                         dest='exec_file')
185
186    parser.add_argument( '--adb',
187                         help='Use specific adb command',
188                         dest='adb_cmd')
189
190    parser.add_argument( '--awk',
191                         help='Use specific awk command (unused flag retained for compatability)')
192
193    parser.add_argument( '-e',
194                         help='Connect to single emulator instance....(either this,)',
195                         action='store_true', dest='emulator')
196
197    parser.add_argument( '-d',
198                         help='Connect to single target device........(this,)',
199                         action='store_true', dest='device')
200
201    parser.add_argument( '-s',
202                         help='Connect to specific emulator or device.(or this)',
203                         default=DEVICE_SERIAL,
204                         dest='device_serial')
205
206    parser.add_argument( '-t','--tui',
207                         help='Use tui mode',
208                         action='store_true', dest='tui')
209
210    parser.add_argument( '--gnumake-flag',
211                         help='Flag to pass to gnumake, e.g. NDK_TOOLCHAIN_VERSION=4.8',
212                         action='append', dest='gnumake_flags')
213
214    parser.add_argument( '--nowait',
215                         help='Do not wait for debugger to attach (may miss early JNI breakpoints)',
216                         action='store_true', dest='nowait')
217
218    if os.path.isdir(PYPRPR_GNUSTDCXX_BASE):
219        stdcxx_pypr_versions = [ 'gnustdcxx'+d.replace('gcc','')
220                                 for d in os.listdir(PYPRPR_GNUSTDCXX_BASE)
221                                 if os.path.isdir(os.path.join(PYPRPR_GNUSTDCXX_BASE, d)) ]
222    else:
223        stdcxx_pypr_versions = []
224
225    parser.add_argument( '--stdcxx-py-pr',
226                         help='Specify stdcxx python pretty-printer',
227                         choices=['auto', 'none', 'gnustdcxx'] + stdcxx_pypr_versions + ['stlport'],
228                         default='none', dest='stdcxxpypr')
229
230    args = parser.parse_args()
231
232    VERBOSE = args.verbose
233
234    ndk_bin = ndk_bin_path(NDK)
235    (found_adb,     ADB_CMD)     = find_program('adb',    [ndk_bin])
236    (found_gnumake, GNUMAKE_CMD) = find_program('make',   [ndk_bin])
237    (found_jdb,     JDB_CMD)     = find_program('jdb',    [])
238
239    if not found_gnumake:
240        error('Failed to find GNU make')
241
242    log('Android NDK installation path: %s' % (NDK))
243
244    if args.device:
245        ADB_FLAGS = '-d'
246    if args.emulator:
247        if ADB_FLAGS != '':
248            parser.print_help()
249            exit(1)
250        ADB_FLAGS = '-e'
251    if args.device_serial != '':
252        DEVICE_SERIAL = args.device_serial
253        if ADB_FLAGS != '':
254            parser.print_help()
255            exit(1)
256        ADB_FLAGS = '-s'
257    if args.adb_cmd != None:
258        log('Using specific adb command: %s' % (args.adb_cmd))
259        ADB_CMD = args.adb_cmd
260    if ADB_CMD is None:
261        error('''The 'adb' tool is not in your path.
262       You can change your PATH variable, or use
263       --adb=<executable> to point to a valid one.''')
264    if not os.path.isfile(ADB_CMD):
265        error('Could not run ADB with: %s' % (ADB_CMD))
266
267    if args.project != None:
268        PROJECT = args.project
269
270    if args.start != None:
271        OPTION_START = args.start
272
273    if args.launch_name != None:
274        OPTION_LAUNCH = args.launch_name
275
276    if args.launch_list != None:
277        OPTION_LAUNCH_LIST = args.launch_list
278
279    if args.force != None:
280        OPTION_FORCE = args.force
281
282    if args.exec_file != None:
283        OPTION_EXEC = args.exec_file
284
285    if args.tui != False:
286        OPTION_TUI = True
287
288    if args.delay != None:
289        DELAY = args.delay
290
291    if args.gnumake_flags != None:
292        GNUMAKE_FLAGS = args.gnumake_flags
293
294    if args.nowait == True:
295        OPTION_WAIT = []
296    elif not found_jdb:
297        error('Failed to find jdb.\n..you can use --nowait to disable jdb\n..but may miss early breakpoints.')
298
299    OPTION_STDCXXPYPR = args.stdcxxpypr
300
301def get_build_var(var):
302    global GNUMAKE_CMD, GNUMAKE_FLAGS, NDK, PROJECT
303    text = subprocess.check_output([GNUMAKE_CMD,
304                                  '--no-print-dir',
305                                  '-f',
306                                  NDK+'/build/core/build-local.mk',
307                                  '-C',
308                                  PROJECT,
309                                  'DUMP_'+var] + GNUMAKE_FLAGS
310                                  )
311    # replace('\r', '') due to Windows crlf (\r\n)
312    #  ...universal_newlines=True causes bytes to be returned
313    #     rather than a str
314    return text.decode('ascii').replace('\r', '').splitlines()[0]
315
316def get_build_var_for_abi(var, abi):
317    global GNUMAKE_CMD, GNUMAKE_FLAGS, NDK, PROJECT
318    text = subprocess.check_output([GNUMAKE_CMD,
319                                   '--no-print-dir',
320                                   '-f',
321                                   NDK+'/build/core/build-local.mk',
322                                   '-C',
323                                   PROJECT,
324                                   'DUMP_'+var,
325                                   'APP_ABI='+abi] + GNUMAKE_FLAGS,
326                                   )
327    return text.decode('ascii').replace('\r', '').splitlines()[0]
328
329# Silent if gdb is running in tui mode to keep things tidy.
330def output_gdbserver(text):
331    if not OPTION_TUI or OPTION_TUI != 'running':
332        print(text)
333
334# Likewise, silent in tui mode (also prepends 'JDB :: ')
335def output_jdb(text):
336    if not OPTION_TUI or OPTION_TUI != 'running':
337        print('JDB :: %s' % text)
338
339def input_jdb(inhandle):
340    while True:
341        inhandle.write('\n')
342        time.sleep(1.0)
343
344def background_spawn(args, redirect_stderr, output_fn, redirect_stdin = None, input_fn = None):
345
346    def async_stdout(outhandle, queue, output_fn):
347        for line in iter(outhandle.readline, b''):
348            output_fn(line.replace('\r', '').replace('\n', ''))
349        outhandle.close()
350
351    def async_stderr(outhandle, queue, output_fn):
352        for line in iter(outhandle.readline, b''):
353            output_fn(line.replace('\r', '').replace('\n', ''))
354        outhandle.close()
355
356    def async_stdin(inhandle, queue, input_fn):
357        input_fn(inhandle)
358        inhandle.close()
359
360    if redirect_stderr:
361        used_stderr = subprocess.PIPE
362    else:
363        used_stderr = subprocess.STDOUT
364    if redirect_stdin:
365        used_stdin = subprocess.PIPE
366    else:
367        used_stdin = None
368    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=used_stderr, stdin=used_stdin,
369                         bufsize=1, close_fds='posix' in sys.builtin_module_names)
370    qo = Queue()
371    to = Thread(target=async_stdout, args=(p.stdout, qo, output_fn))
372    to.daemon = True
373    to.start()
374    if redirect_stderr:
375        te = Thread(target=async_stderr, args=(p.stderr, qo, output_fn))
376        te.daemon = True
377        te.start()
378    if redirect_stdin:
379        ti = Thread(target=async_stdin, args=(p.stdin, qo, input_fn))
380        ti.daemon = True
381        ti.start()
382
383def adb_cmd(redirect_stderr, args, log_command=False, adb_trace=False, background=False):
384    global ADB_CMD, ADB_FLAGS, DEVICE_SERIAL
385    fullargs = [ADB_CMD]
386    if ADB_FLAGS != '':
387        fullargs += [ADB_FLAGS]
388    if DEVICE_SERIAL != '':
389        fullargs += [DEVICE_SERIAL]
390    if isinstance(args, str):
391        fullargs.append(args)
392    else:
393        fullargs += [arg for arg in args]
394    new_env = os.environ.copy()
395    retval = 0
396    if adb_trace:
397        new_env["ADB_TRACE"] = "1"
398    if background:
399        if log_command:
400            log('## COMMAND: adb_cmd %s [BACKGROUND]' % (' '.join(args)))
401        background_spawn(fullargs, redirect_stderr, output_gdbserver)
402        return 0, ''
403    else:
404        if log_command:
405            log('## COMMAND: adb_cmd %s' % (' '.join(args)))
406        try:
407            if redirect_stderr:
408                text = subprocess.check_output(fullargs,
409                                               stderr=subprocess.STDOUT,
410                                               env=new_env
411                                               )
412            else:
413                text = subprocess.check_output(fullargs,
414                                               env=new_env
415                                               )
416        except subprocess.CalledProcessError as e:
417            retval = e.returncode
418            text = e.output
419        # rstrip() because of final newline.
420        return retval, text.decode('ascii').replace('\r', '').rstrip()
421
422def _adb_var_shell(args, redirect_stderr=False, log_command=True):
423    if log_command:
424        log('## COMMAND: adb_cmd shell %s' % (' '.join(args)))
425    arg_str = str(' '.join(args)+' ; echo $?')
426    adb_ret,output = adb_cmd(redirect_stderr=redirect_stderr,
427                           args=['shell', arg_str], log_command=False)
428    output = output.splitlines()
429    retcode = int(output.pop())
430    return retcode,'\n'.join(output)
431
432def adb_var_shell(args, log_command=False):
433    return _adb_var_shell(args, redirect_stderr=False, log_command=log_command)
434
435def adb_var_shell2(args, log_command=False):
436    return _adb_var_shell(args, redirect_stderr=True, log_command=log_command)
437
438# Return the PID of a given package or program, or 0 if it doesn't run
439# $1: Package name ("com.example.hellojni") or program name ("/lib/gdbserver")
440# Out: PID number, or 0 if not running
441#
442def get_pid_of(package_name):
443    '''
444    Some custom ROMs use busybox instead of toolbox for ps.
445    Without -w, busybox truncates the output, and very long
446    package names like com.exampleisverylongtoolongbyfar.plasma
447    exceed the limit.
448    '''
449    ps_command = 'ps'
450    retcode,output = adb_cmd(False, ['shell', 'readlink $(which ps)'])
451    if output:
452        output = output.replace('\r', '').splitlines()[0]
453    if output == 'busybox':
454        ps_command = 'ps -w'
455    retcode,output = adb_cmd(False,['shell', ps_command])
456    output = output.replace('\r', '').splitlines()
457    columns = output.pop(0).split()
458    try:
459        PID_column = columns.index('PID')
460    except:
461        PID_column = 1
462    while output:
463        columns = output.pop().split()
464        if columns.pop() == package_name:
465            return 0,int(columns[PID_column])
466    return 1,0
467
468def extract_package_name(xmlfile):
469    '''
470    The name itself is the value of the 'package' attribute in the
471    'manifest' element.
472    '''
473    tree = ElementTree.ElementTree(file=xmlfile)
474    root = tree.getroot()
475    if 'package' in root.attrib:
476        return root.attrib['package']
477    return None
478
479def extract_debuggable(xmlfile):
480    '''
481    simply extract the 'android:debuggable' attribute value from
482    the first <manifest><application> element we find.
483    '''
484    tree = ElementTree.ElementTree(file=xmlfile)
485    root = tree.getroot()
486    for application in root.iter('application'):
487        for k in application.attrib.keys():
488            if str(k).endswith('debuggable'):
489                return application.attrib[k] == 'true'
490    return False
491
492def extract_launchable(xmlfile):
493    '''
494    A given application can have several activities, and each activity
495    can have several intent filters. We want to only list, in the final
496    output, the activities which have a intent-filter that contains the
497    following elements:
498
499      <action android:name="android.intent.action.MAIN" />
500      <category android:name="android.intent.category.LAUNCHER" />
501    '''
502    tree = ElementTree.ElementTree(file=xmlfile)
503    root = tree.getroot()
504    launchable_activities = []
505    for application in root.iter('application'):
506        for activity in application.iter('activity'):
507            for intent_filter in activity.iter('intent-filter'):
508                found_action_MAIN = False
509                found_category_LAUNCHER = False
510                for child in intent_filter:
511                    if child.tag == 'action':
512                        if True in [str(child.attrib[k]).endswith('MAIN') for k in child.attrib.keys()]:
513                            found_action_MAIN = True
514                    if child.tag == 'category':
515                        if True in [str(child.attrib[k]).endswith('LAUNCHER') for k in child.attrib.keys()]:
516                            found_category_LAUNCHER = True
517                if found_action_MAIN and found_category_LAUNCHER:
518                    names = [str(activity.attrib[k]) for k in activity.attrib.keys() if str(k).endswith('name')]
519                    for name in names:
520                        if name[0] != '.':
521                            name = '.'+name
522                        launchable_activities.append(name)
523    return launchable_activities
524
525def main():
526    global ADB_CMD, NDK, PROJECT
527    global JDB_CMD
528    global OPTION_START, OPTION_LAUNCH, OPTION_LAUNCH_LIST
529    global OPTION_FORCE, OPTION_EXEC, OPTION_TUI, OPTION_WAIT
530    global OPTION_STDCXXPYPR
531    global PYPRPR_BASE, PYPRPR_GNUSTDCXX_BASE
532
533    if NDK.find(' ')!=-1:
534        error('NDK path cannot contain space')
535    handle_args()
536    if OPTION_EXEC:
537        if not os.path.isfile(OPTION_EXEC):
538            error('Invalid initialization file: %s' % (OPTION_EXEC))
539    ADB_VERSION = subprocess.check_output([ADB_CMD, 'version'],
540                                        ).decode('ascii').replace('\r', '').splitlines()[0]
541    log('ADB version found: %s' % (ADB_VERSION))
542    if DEVICE_SERIAL == '':
543        log('Using ADB flags: %s' % (ADB_FLAGS))
544    else:
545        log('Using ADB flags: %s "%s"' % (ADB_FLAGS,DEVICE_SERIAL))
546    if PROJECT != None:
547        log('Using specified project path: %s' % (PROJECT))
548        if not os.path.isdir(PROJECT):
549            error('Your --project option does not point to a directory!')
550        if not os.path.isfile(PROJECT+os.sep+MANIFEST):
551            error('''Your --project does not point to an Android project path!
552       It is missing a %s file.''' % (MANIFEST))
553    else:
554        # Assume we are in the project directory
555        if os.path.isfile(MANIFEST):
556            PROJECT = '.'
557        else:
558            PROJECT = ''
559            CURDIR = os.getcwd()
560
561            while CURDIR != os.path.dirname(CURDIR):
562                if os.path.isfile(CURDIR+os.sep+MANIFEST):
563                    PROJECT=CURDIR
564                    break
565                CURDIR = os.path.dirname(CURDIR)
566
567            if not os.path.isdir(PROJECT):
568                error('Launch this script from an application project directory, or use --project=<path>.')
569        log('Using auto-detected project path: %s' % (PROJECT))
570
571    PACKAGE_NAME = extract_package_name(PROJECT+os.sep+MANIFEST)
572    if PACKAGE_NAME is None:
573        PACKAGE_NAME = '<none>'
574    log('Found package name: %s' % (PACKAGE_NAME))
575    if PACKAGE_NAME == '<none>':
576        error('''Could not extract package name from %s.
577       Please check that the file is well-formed!''' % (PROJECT+os.sep+MANIFEST))
578    if OPTION_LAUNCH_LIST:
579        log('Extracting list of launchable activities from manifest:')
580        print(' '.join(extract_launchable(PROJECT+os.sep+MANIFEST)))
581        exit(0)
582    APP_ABIS = get_build_var('APP_ABI').split(' ')
583    if 'all' in APP_ABIS:
584        ALL_ABIS = get_build_var('NDK_ALL_ABIS').split(' ')
585        APP_ABIS = APP_ABIS[:APP_ABIS.index('all')]+ALL_ABIS+APP_ABIS[APP_ABIS.index('all')+1:]
586    log('ABIs targetted by application: %s' % (' '.join(APP_ABIS)))
587
588    retcode,ADB_TEST = adb_cmd(True,['shell', 'ls'])
589    if retcode != 0:
590        print(ADB_TEST)
591        error('''Could not connect to device or emulator!
592       Please check that an emulator is running or a device is connected
593       through USB to this machine. You can use -e, -d and -s <serial>
594       in case of multiple ones.''')
595
596    retcode,API_LEVEL = adb_var_shell(['getprop', 'ro.build.version.sdk'])
597    if retcode != 0 or API_LEVEL == '':
598        error('''Could not find target device's supported API level!
599ndk-gdb will only work if your device is running Android 2.2 or higher.''')
600    API_LEVEL = int(API_LEVEL)
601    log('Device API Level: %d' % (API_LEVEL))
602    if API_LEVEL < 8:
603        error('''ndk-gdb requires a target device running Android 2.2 (API level 8) or higher.
604The target device is running API level %d!''' % (API_LEVEL))
605    COMPAT_ABI = []
606    _,CPU_ABI1 = adb_var_shell(['getprop', 'ro.product.cpu.abi'])
607    _,CPU_ABI2 = adb_var_shell(['getprop', 'ro.product.cpu.abi2'])
608    # Both CPU_ABI1 and CPU_ABI2 may contain multiple comma-delimited abis.
609    # Concatanate CPU_ABI1 and CPU_ABI2.
610    CPU_ABIS = CPU_ABI1.split(',')+CPU_ABI2.split(',')
611    log('Device CPU ABIs: %s' % (' '.join(CPU_ABIS)))
612    COMPAT_ABI = [ABI for ABI in CPU_ABIS if ABI in APP_ABIS]
613
614    if not len(COMPAT_ABI):
615        error('''The device does not support the application's targetted CPU ABIs!
616       Device supports:  %s
617       Package supports: %s''' % (' '.join(CPU_ABIS),' '.join(APP_ABIS)))
618    COMPAT_ABI = COMPAT_ABI[0]
619    log('Compatible device ABI: %s' % (COMPAT_ABI))
620    GDBSETUP_INIT = get_build_var_for_abi('NDK_APP_GDBSETUP', COMPAT_ABI)
621    log('Using gdb setup init: %s' % (GDBSETUP_INIT))
622
623    TOOLCHAIN_PREFIX = get_build_var_for_abi('TOOLCHAIN_PREFIX', COMPAT_ABI)
624    log('Using toolchain prefix: %s' % (TOOLCHAIN_PREFIX))
625
626    APP_OUT = get_build_var_for_abi('TARGET_OUT', COMPAT_ABI)
627    log('Using app out directory: %s' % (APP_OUT))
628    DEBUGGABLE = extract_debuggable(PROJECT+os.sep+MANIFEST)
629    log('Found debuggable flag: %s' % ('true' if DEBUGGABLE==True else 'false'))
630    # If gdbserver exists, then we built with 'ndk-build NDK_DEBUG=1' and it's
631    # ok to not have android:debuggable set to true in the original manifest.
632    # However, if this is not the case, then complain!!
633    #
634    gdbserver_path = os.path.join(PROJECT,'libs',COMPAT_ABI,'gdbserver')
635    if not DEBUGGABLE:
636        if os.path.isfile(gdbserver_path):
637            log('Found gdbserver under libs/%s, assuming app was built with NDK_DEBUG=1' % (COMPAT_ABI))
638        else:
639            error('''Package %s is not debuggable ! You can fix that in two ways:
640
641  - Rebuilt with the NDK_DEBUG=1 option when calling 'ndk-build'.
642
643  - Modify your manifest to set android:debuggable attribute to "true",
644    then rebuild normally.
645
646After one of these, re-install to the device!''' % (PACKAGE_NAME))
647    elif not os.path.isfile(gdbserver_path):
648        error('''Could not find gdbserver binary under %s/libs/%s
649       This usually means you modified your AndroidManifest.xml to set
650       the android:debuggable flag to 'true' but did not rebuild the
651       native binaries. Please call 'ndk-build' to do so,
652       *then* re-install to the device!''' % (PROJECT,COMPAT_ABI))
653
654    # Let's check that 'gdbserver' is properly installed on the device too. If this
655    # is not the case, the user didn't install the proper package after rebuilding.
656    #
657    retcode,DEVICE_GDBSERVER = adb_var_shell2(['ls', '/data/data/%s/lib/gdbserver' % (PACKAGE_NAME)])
658    if retcode:
659        error('''Non-debuggable application installed on the target device.
660       Please re-install the debuggable version!''')
661    log('Found device gdbserver: %s' % (DEVICE_GDBSERVER))
662
663    # Find the <dataDir> of the package on the device
664    retcode,DATA_DIR = adb_var_shell2(['run-as', PACKAGE_NAME, '/system/bin/sh', '-c', 'pwd'])
665    if retcode or DATA_DIR == '':
666        error('''Could not extract package's data directory. Are you sure that
667       your installed application is debuggable?''')
668    log("Found data directory: '%s'" % (DATA_DIR))
669
670    # Launch the activity if needed
671    if OPTION_START:
672        if not OPTION_LAUNCH:
673            OPTION_LAUNCH = extract_launchable(PROJECT+os.sep+MANIFEST)
674            if not len(OPTION_LAUNCH):
675                error('''Could not extract name of launchable activity from manifest!
676           Try to use --launch=<name> directly instead as a work-around.''')
677            log('Found first launchable activity: %s' % (OPTION_LAUNCH[0]))
678        if not len(OPTION_LAUNCH):
679            error('''It seems that your Application does not have any launchable activity!
680       Please fix your manifest file and rebuild/re-install your application.''')
681
682    if OPTION_LAUNCH:
683        log('Launching activity: %s/%s' % (PACKAGE_NAME,OPTION_LAUNCH[0]))
684        retcode,LAUNCH_OUTPUT=adb_cmd(True,
685                                      ['shell', 'am', 'start'] + OPTION_WAIT + ['-n', '%s/%s' % (PACKAGE_NAME,OPTION_LAUNCH[0])],
686                                      log_command=True)
687        if retcode:
688            error('''Could not launch specified activity: %s
689       Use --launch-list to dump a list of valid values.''' % (OPTION_LAUNCH[0]))
690
691        # Sleep a bit, it sometimes take one second to start properly
692        # Note that we use the 'sleep' command on the device here.
693        #
694        adb_cmd(True, ['shell', 'sleep', '%f' % (DELAY)], log_command=True)
695
696    # Find the PID of the application being run
697    retcode,PID = get_pid_of(PACKAGE_NAME)
698    log('Found running PID: %d' % (PID))
699    if retcode or PID == 0:
700        if OPTION_LAUNCH:
701            error('''Could not extract PID of application on device/emulator.
702       Weird, this probably means one of these:
703
704         - The installed package does not match your current manifest.
705         - The application process was terminated.
706
707       Try using the --verbose option and look at its output for details.''')
708        else:
709            error('''Could not extract PID of application on device/emulator.
710       Are you sure the application is already started?
711       Consider using --start or --launch=<name> if not.''')
712
713    # Check that there is no other instance of gdbserver running
714    retcode,GDBSERVER_PID = get_pid_of('lib/gdbserver')
715    if not retcode and not GDBSERVER_PID == 0:
716        if not OPTION_FORCE:
717            error('Another debug session running, Use --force to kill it.')
718        log('Killing existing debugging session')
719        adb_cmd(False, ['shell', 'kill -9 %s' % (GDBSERVER_PID)])
720
721    # Launch gdbserver now
722    DEBUG_SOCKET = 'debug-socket'
723    adb_cmd(False,
724            ['shell', 'run-as', PACKAGE_NAME, 'lib/gdbserver', '+%s' % (DEBUG_SOCKET), '--attach', str(PID)],
725            log_command=True, adb_trace=True, background=True)
726    log('Launched gdbserver succesfully.')
727
728# Make sure gdbserver was launched - debug check.
729#    adb_var_shell(['sleep', '0.1'], log_command=False)
730#    retcode,GDBSERVER_PID = get_pid_of('lib/gdbserver')
731#    if retcode or GDBSERVER_PID == 0:
732#        error('Could not launch gdbserver on the device?')
733#    log('Launched gdbserver succesfully (PID=%s)' % (GDBSERVER_PID))
734
735    # Setup network redirection
736    log('Setup network redirection')
737    retcode,_ = adb_cmd(False,
738                        ['forward', 'tcp:%d' % (DEBUG_PORT), 'localfilesystem:%s/%s' % (DATA_DIR,DEBUG_SOCKET)],
739                        log_command=True)
740    if retcode:
741        error('''Could not setup network redirection to gdbserver?
742       Maybe using --port=<port> to use a different TCP port might help?''')
743
744    # Get the app_server binary from the device
745    APP_PROCESS = '%s/app_process' % (APP_OUT)
746    adb_cmd(False, ['pull', '/system/bin/app_process', APP_PROCESS], log_command=True)
747    log('Pulled app_process from device/emulator.')
748
749    adb_cmd(False, ['pull', '/system/bin/linker', '%s/linker' % (APP_OUT)], log_command=True)
750    log('Pulled linker from device/emulator.')
751
752    adb_cmd(False, ['pull', '/system/lib/libc.so', '%s/libc.so' % (APP_OUT)], log_command=True)
753    log('Pulled libc.so from device/emulator.')
754
755    # Setup JDB connection, for --start or --launch
756    if (OPTION_START != None or OPTION_LAUNCH != None) and len(OPTION_WAIT):
757        log('Set up JDB connection, using jdb command: %s' % JDB_CMD)
758        retcode,_ = adb_cmd(False,
759                            ['forward', 'tcp:%d' % (JDB_PORT), 'jdwp:%d' % (PID)],
760                            log_command=True)
761        time.sleep(1.0)
762        if retcode:
763            error('Could not forward JDB port')
764        background_spawn([JDB_CMD,'-connect','com.sun.jdi.SocketAttach:hostname=localhost,port=%d' % (JDB_PORT)], True, output_jdb, True, input_jdb)
765        time.sleep(1.0)
766
767    # Work out the python pretty printer details.
768    pypr_folder = None
769    pypr_function = None
770
771    # Automatic determination of pypr.
772    if OPTION_STDCXXPYPR == 'auto':
773        libdir = os.path.join(PROJECT,'libs',COMPAT_ABI)
774        libs = [ f for f in os.listdir(libdir)
775                 if os.path.isfile(os.path.join(libdir, f)) and f.endswith('.so') ]
776        if 'libstlport_shared.so' in libs:
777            OPTION_STDCXXPYPR = 'stlport'
778        elif 'libgnustl_shared.so' in libs:
779            OPTION_STDCXXPYPR = 'gnustdcxx'
780
781    if OPTION_STDCXXPYPR == 'stlport':
782        pypr_folder = PYPRPR_BASE + 'stlport/gppfs-0.2/stlport'
783        pypr_function = 'register_stlport_printers'
784    elif OPTION_STDCXXPYPR.startswith('gnustdcxx'):
785        if OPTION_STDCXXPYPR == 'gnustdcxx':
786            NDK_TOOLCHAIN_VERSION = get_build_var_for_abi('NDK_TOOLCHAIN_VERSION', COMPAT_ABI)
787            log('Using toolchain version: %s' % (NDK_TOOLCHAIN_VERSION))
788            pypr_folder = PYPRPR_GNUSTDCXX_BASE + 'gcc-' + NDK_TOOLCHAIN_VERSION
789        else:
790            pypr_folder = PYPRPR_GNUSTDCXX_BASE + OPTION_STDCXXPYPR.replace('gnustdcxx-','gcc-')
791        pypr_function = 'register_libstdcxx_printers'
792
793    # Now launch the appropriate gdb client with the right init commands
794    #
795    GDBCLIENT = '%sgdb' % (TOOLCHAIN_PREFIX)
796    GDBSETUP = '%s/gdb.setup' % (APP_OUT)
797    shutil.copyfile(GDBSETUP_INIT, GDBSETUP)
798    with open(GDBSETUP, "a") as gdbsetup:
799        #uncomment the following to debug the remote connection only
800        #gdbsetup.write('set debug remote 1\n')
801        gdbsetup.write('file '+APP_PROCESS+'\n')
802        gdbsetup.write('target remote :%d\n' % (DEBUG_PORT))
803        gdbsetup.write('set breakpoint pending on\n')
804
805        if pypr_function:
806            gdbsetup.write('python\n')
807            gdbsetup.write('import sys\n')
808            gdbsetup.write('sys.path.append("%s")\n' % pypr_folder)
809            gdbsetup.write('from printers import %s\n' % pypr_function)
810            gdbsetup.write('%s(None)\n' % pypr_function)
811            gdbsetup.write('end\n')
812
813        if OPTION_EXEC:
814            with open(OPTION_EXEC, 'r') as execfile:
815                for line in execfile:
816                    gdbsetup.write(line)
817    gdbsetup.close()
818
819    gdbargs = [GDBCLIENT, '-x', '%s' % (GDBSETUP)]
820    if OPTION_TUI:
821        gdbhelp = subprocess.check_output([GDBCLIENT, '--help']).decode('ascii')
822        try:
823            gdbhelp.index('--tui')
824            gdbargs.append('--tui')
825            OPTION_TUI = 'running'
826        except:
827            print('Warning: Disabled tui mode as %s does not support it' % (os.path.basename(GDBCLIENT)))
828    gdbp = subprocess.Popen(gdbargs)
829    while gdbp.returncode is None:
830        try:
831            gdbp.communicate()
832        except KeyboardInterrupt:
833            pass
834    log("Exited gdb, returncode %d" % gdbp.returncode)
835
836if __name__ == '__main__':
837    main()
838