cast.py

#!/usr/bin/python
from sys import stderr
from re import match

__author__ = 'mmin18'
__version__ = '1.51927'
__plugin__ = '1'

import argparse
from distutils.version import LooseVersion
import io
import json
import os
import re
import shutil
from subprocess import Popen, PIPE
import sys
import time
import zipfile

# http://stackoverflow.com/questions/377017/test-if-executable-exists-in-python
def is_exe(fpath):
    return os.path.isfile(fpath) and os.access(fpath, os.X_OK)


def which(program):
    fpath, fname = os.path.split(program)
    if fpath:
        if is_exe(program):
            return program
    else:
        for path in os.environ["PATH"].split(os.pathsep):
            path = path.strip('"')
            exe_file = os.path.join(path, program)
            if is_exe(exe_file):
                return exe_file

    return None


def cexec_fail_exit(args, code, stdout, stderr):
    if code != 0:
        print('Fail to exec %s' % args)
        print(stdout)
        print(stderr)
        exit(code)


def cexec(args, callback=cexec_fail_exit, addPath=None, exitcode=1):
    env = None
    if addPath:
        import copy
        env = copy.copy(os.environ)
        env['PATH'] = addPath + os.path.pathsep + env['PATH']
    p = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE, env=env)
    output, err = p.communicate()
    code = p.returncode

    if code and exitcode:
        code = exitcode
    if callback:
        callback(args, code, output, err)
    return output


def curl(url, body=None, ignoreError=False, exitcode=1):
    try:
        if sys.version_info >= (3, 0):
            import urllib.request
            return urllib.request.urlopen(url, data=body).read().decode('utf-8').strip()
        else:
            import urllib2
            return urllib2.urlopen(url, data=body).read().decode('utf-8').strip()
    except Exception as e:
        if ignoreError:
            return None
        else:
            print(e)
            exit(exitcode)


def open_as_text(path):
    if not path or not os.path.isfile(path):
        return ''
    with io.open(path, 'r', errors='replace') as f:
        data = f.read()
        return data
    print('fail to open %s' % path)
    return ''


def is_gradle_project(directory):
    return os.path.isfile(os.path.join(directory, 'build.gradle'))


def parse_properties(path):
    return os.path.isfile(path) and dict(line.strip().split('=') for line in open(path) if ('=' in line and not line.startswith('#'))) or {}


def balanced_braces(arg):
    if '{' not in arg:
        return ''
    chars = []
    n = 0
    for c in arg:
        if c == '{':
            if n > 0:
                chars.append(c)
            n += 1
        elif c == '}':
            n -= 1
            if n > 0:
                chars.append(c)
            elif n == 0:
                return ''.join(chars).lstrip().rstrip()
        elif n > 0:
            chars.append(c)
    return ''


def remove_comments(code):
    # remove comments in groovy
    return re.sub(r'''(/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/)|(//.*)''', '', code)


def __deps_list_eclipse(a_list, project):
    prop = parse_properties(os.path.join(project, 'project.properties'))
    for i in range(1, 100):
        dep = prop.get('android.library.reference.%d' % i)
        if dep:
            absdep = os.path.abspath(os.path.join(project, dep))
            __deps_list_eclipse(a_list, absdep)
            if not absdep in a_list:
                a_list.append(absdep)


def __deps_list_gradle(a_list, project):
    sFile = open_as_text(os.path.join(project, 'build.gradle'))
    sFile = remove_comments(sFile)
    ideps = []
    # for depends in re.findall(r'dependencies\s*\{.*?\}', str, re.DOTALL | re.MULTILINE):
    for m in re.finditer(r'dependencies\s*\{', sFile):
        depends = balanced_braces(sFile[m.start():])
        for proj in re.findall(r'''compile\s+project\s*\(.*['"]:(.+)['"].*\)''', depends):
            ideps.append(proj.replace(':', os.path.sep))
    if len(ideps) == 0:
        return
    # get the real path
    ex_libs = {}
    par = os.path.abspath(os.path.join(project, os.pardir))
    if os.path.isfile(os.path.join(par, 'settings.gradle')):
        data = open_as_text(os.path.join(par, 'settings.gradle'))
        for proj in re.findall(r'''project\(\'\:(.+)\'\)\.projectDir\s*\=\s*new\s*File\(.*['"](.+)['"]\)''', data):
            ex_libs[proj[0]] = proj[1]
    deptmp = []
    for dep in ideps:
        if dep in ex_libs:
            deptmp.append(ex_libs[dep])
        else:
            deptmp.append(dep)
    ideps = deptmp
    path = project
    for i in range(1, 3):
        path = os.path.abspath(os.path.join(path, os.path.pardir))
        pathtmp = path
        b = True
        deps = []
        for idep in ideps:
            for par in re.findall(r'.*(\.\.\/).+', idep):
                pathtmp = os.path.abspath(os.path.join(path, os.path.pardir))
            idep = idep.replace('../', '')
            dep = os.path.join(pathtmp, idep)
            if not os.path.isdir(dep):
                b = False
                break
            deps.append(dep)
        if b:
            for dep in deps:
                __deps_list_gradle(a_list, dep)
                if not dep in a_list:
                    a_list.append(dep)
            break


def deps_list(directory):
    if is_gradle_project(directory):
        a_list = []
        __deps_list_gradle(a_list, directory)
        return a_list
    else:
        a_list = []
        __deps_list_eclipse(a_list, directory)
        return a_list


def manifest_path(directory):
    if os.path.isfile(os.path.join(directory, 'AndroidManifest.xml')):
        return os.path.join(directory, 'AndroidManifest.xml')
    if os.path.isfile(os.path.join(directory, 'src', 'main', 'AndroidManifest.xml')):
        return os.path.join(directory, 'src', 'main', 'AndroidManifest.xml')


def package_name(directory):
    path = manifest_path(directory)
    data = open_as_text(path)
    for pn in re.findall('package=\"([\w\d_\.]+)\"', data):
        return pn


def get_apk_path(directory):
    if not is_gradle_project(directory):
        apkpath = os.path.join(directory, 'bin')
    else:
        apkpath = os.path.join(directory, 'build', 'outputs', 'apk')
    # Get the lastmodified *.apk file
    maxt = 0
    maxd = None
    for dirpath, dirnames, files in os.walk(apkpath):
        for fn in files:
            if fn.endswith('.apk') and not fn.endswith('-unaligned.apk') and not fn.endswith('-unsigned.apk'):
                lastModified = os.path.getmtime(os.path.join(dirpath, fn))
                if lastModified > maxt:
                    maxt = lastModified
                    maxd = os.path.join(dirpath, fn)
    return maxd


def package_name_fromapk(directory, sdkdir):
    # Get the package name from maxd
    aaptpath = get_aapt(sdkdir)
    if aaptpath:
        apkpath = get_apk_path(directory)
        if apkpath:
            aaptargs = [aaptpath, 'dump', 'badging', apkpath]
            output = cexec(aaptargs, callback=None)
            for pn in re.findall('package: name=\'([^\']+)\'', output):
                return pn
    return package_name(directory)


def get_latest_packagename(dirlist, sdkdir):
    maxt = 0
    maxd = None
    for directory in dirlist:
        if directory:
            apkfile = get_apk_path(directory)
            if apkfile:
                lastModified = os.path.getmtime(apkfile)
                if lastModified > maxt:
                    maxt = lastModified
                    maxd = directory
    if maxd:
        return package_name_fromapk(maxd, sdkdir)


def isRes_Name(name):
    if name == 'drawable' or name.startswith('drawable-'):
        return 2
    if name == 'layout' or name.startswith('layout-'):
        return 2
    if name == 'values' or name.startswith('values-'):
        return 2
    if name == 'anim' or name.startswith('anim-'):
        return 1
    if name == 'color' or name.startswith('color-'):
        return 1
    if name == 'menu' or name.startswith('menu-'):
        return 1
    if name == 'raw' or name.startswith('raw-'):
        return 1
    if name == 'xml' or name.startswith('xml-'):
        return 1
    if name == 'mipmap' or name.startswith('mipmap-'):
        return 1
    if name == 'animator' or name.startswith('animator-'):
        return 1
    return 0


def count_Res_Dir(directory):
    c = 0
    d = 0
    if os.path.isdir(directory):
        for subd in os.listdir(directory):
            v = isRes_Name(subd)
            if v > 1:
                d += 1
            if v > 0:
                c += 1
    if d == 0:
        return 0
    return c


def count_Asset_Dir(directory):
    a = 0
    if os.path.isdir(directory):
        for subd in os.listdir(directory):
            if not subd.startswith('.'):
                a += 1
    return a


def res_dir(directory):
    dir1 = os.path.join(directory, 'res')
    dir2 = os.path.join(directory, 'src', 'main', 'res')
    a = count_Res_Dir(dir1)
    b = count_Res_Dir(dir2)
    if b == 0 and a == 0:
        return None
    elif b > a:
        return dir2
    else:
        return dir1


def asset_dir(directory):
    dir1 = os.path.join(directory, 'assets')
    dir2 = os.path.join(directory, 'src', 'main', 'assets')
    a = count_Asset_Dir(dir1)
    b = count_Asset_Dir(dir2)
    if b == 0 and a == 0:
        return None
    elif b > a:
        return dir2
    else:
        return dir1


def get_asset_from_apk(apk_filename, dest_dir):
    with zipfile.ZipFile(apk_filename) as zf:
        for member in zf.infolist():
            path = dest_dir
            if member.filename.startswith('assets/'):
                zf.extract(member, path)


def count_Src_Dir2(directory, lastBuild=0, a_list=None):
    count = 0
    lastModified = 0
    for dirpath, dirnames, files in os.walk(directory):
        if re.findall(r'[/\\+]androidTest[/\\+]', dirpath) or '/.' in dirpath:
            continue
        for fn in files:
            if fn.endswith('.java'):
                count += 1
                mt = os.path.getmtime(os.path.join(dirpath, fn))
                lastModified = max(lastModified, mt)
                if a_list != None and mt > lastBuild:
                    a_list.append(os.path.join(dirpath, fn))
    return (count, lastModified)


def src_dir2(directory, lastBuild=0, alist=None):
    for srcdir in [os.path.join(directory, 'src', 'main', 'java'), os.path.join(directory, 'src')]:
        olist = None
        if alist != None:
            olist = []
        (count, lastModified) = count_Src_Dir2(srcdir, lastBuild=lastBuild, a_list=olist)
        if count > 0:
            if alist != None:
                alist.extend(olist)
            return (srcdir, count, lastModified)
    return (None, 0, 0)


def lib_dir(directory):
    ddir = os.path.join(directory, 'libs')
    if os.path.isdir(ddir):
        return ddir
    else:
        return None


def is_launchable_project(directory):
    if is_gradle_project(directory):
        data = open_as_text(os.path.join(directory, 'build.gradle'))
        data = remove_comments(data)
        if re.findall(r'''apply\s+plugin:\s*['"]com.android.application['"]''', data, re.MULTILINE):
            return True
    elif os.path.isfile(os.path.join(directory, 'project.properties')):
        data = open_as_text(os.path.join(directory, 'project.properties'))
        if re.findall(r'''^\s*target\s*=.*$''', data, re.MULTILINE) and not re.findall(r'''^\s*android.library\s*=\s*true\s*$''', data, re.MULTILINE):
            return True
    return False


def __append_project(a_list, directory, depth):
    if package_name(directory):
        a_list.append(directory)
    elif depth > 0:
        for cname in os.listdir(directory):
            if cname == 'build' or cname == 'bin':
                continue
            cdir = os.path.join(directory, cname)
            if os.path.isdir(cdir):
                __append_project(a_list, cdir, depth - 1)


def list_projects(directory):
    a_list = []
    if os.path.isfile(os.path.join(directory, 'settings.gradle')):
        data = open_as_text(os.path.join(directory, 'settings.gradle'))
        for line in re.findall(r'''include\s*(.+)''', data):
            for proj in re.findall(r'''[\s,]+['"](.*?)['"]''', ',' + line):
                dproj = (proj.startswith(':') and proj[1:] or proj).replace(':', os.path.sep)
                cdir = os.path.join(directory, dproj)
                if package_name(cdir):
                    a_list.append(cdir)
    else:
        __append_project(a_list, directory, 2)
    return a_list


def list_aar_projects(directory, deps):
    pnlist = [package_name(i) for i in deps]
    pnlist.append(package_name(directory))
    list1 = []
    if os.path.isdir(os.path.join(directory, 'build', 'intermediates', 'incremental', 'mergeResources')):
        for dirpath, dirnames, files in os.walk(os.path.join(directory, 'build', 'intermediates', 'incremental', 'mergeResources')):
            if re.findall(r'[/\\+]androidTest[/\\+]', dirpath):
                continue
            for fn in files:
                if fn == 'merger.xml':
                    data = open_as_text(os.path.join(dirpath, fn))
                    for s in re.findall(r'''path="([^"]+)"''', data):
                        (parent, child) = os.path.split(s)
                        if child.endswith('.xml') or child.endswith('.png') or child.endswith('.jpg'):
                            (parent, child) = os.path.split(parent)
                            if isRes_Name(child) and not parent in list1:
                                list1.append(parent)
                        elif os.path.isdir(s) and not s in list1 and count_Res_Dir(s) > 0:
                            list1.append(s)
    # if os.path.isdir(os.path.join(directory, 'build', 'intermediates', 'exploded-aar')):
    #     for dirpath, dirnames, files in os.walk(os.path.join(directory, 'build', 'intermediates', 'exploded-aar')):
    #         if 'res' in dirnames:
    #             list1.append(os.path.join(dirpath,'res'))
    list2 = []
    for ppath in list1:
        parpath = os.path.abspath(os.path.join(ppath, os.pardir))
        pn = package_name(parpath)
        if pn and not pn in pnlist:
            list2.append(ppath)
    return list2


def get_android_jar(path):
    if not os.path.isdir(path):
        return None
    platforms = os.path.join(path, 'platforms')
    if not os.path.isdir(platforms):
        return None
    api = 0
    result = []
    for pd in os.listdir(platforms):
        pd = os.path.join(platforms, pd)
        if os.path.isdir(pd) and os.path.isfile(os.path.join(pd, 'source.properties')) and os.path.isfile(os.path.join(pd, 'android.jar')):
            s = open_as_text(os.path.join(pd, 'source.properties'))
            m = re.search(r'^AndroidVersion.ApiLevel\s*[=:]\s*(.*)$', s, re.MULTILINE)
            if m:
                a = int(m.group(1))
                if a > api:
                    api = a
                    result.append(os.path.join(pd, 'android.jar'))
    api = 0
    for pd in os.listdir(platforms):
        pd = os.path.join(platforms, pd)
        if os.path.isdir(pd) and os.path.isfile(os.path.join(pd, 'source.properties')) and os.path.isfile(os.path.join(pd, 'android.jar')):
            s = open_as_text(os.path.join(pd, 'source.properties'))
            m = re.search(r'^AndroidVersion.ApiLevel\s*[=:]\s*(.*)$', s, re.MULTILINE)
            if m:
                a = int(m.group(1))
                if a > api and a < 23:
                    api = a
                    result.append(os.path.join(pd, 'android.jar'))
    return result


def get_adb(path):
    execname = os.name == 'nt' and 'adb.exe' or 'adb'
    if os.path.isdir(path) and is_exe(os.path.join(path, 'platform-tools', execname)):
        return os.path.join(path, 'platform-tools', execname)


def get_aapt(path):
    execname = os.name == 'nt' and 'aapt.exe' or 'aapt'
    if path and os.path.isdir(path) and os.path.isdir(os.path.join(path, 'build-tools')):
        btpath = os.path.join(path, 'build-tools')
        minv = LooseVersion('0')
        minp = None
        for pn in os.listdir(btpath):
            if is_exe(os.path.join(btpath, pn, execname)):
                if LooseVersion(pn) > minv:
                    minv = LooseVersion(pn)
                    minp = os.path.join(btpath, pn, execname)
        return minp


def get_dx(path):
    execname = os.name == 'nt' and 'dx.bat' or 'dx'
    if os.path.isdir(path) and os.path.isdir(os.path.join(path, 'build-tools')):
        btpath = os.path.join(path, 'build-tools')
        minv = LooseVersion('0')
        minp = None
        for pn in os.listdir(btpath):
            if is_exe(os.path.join(btpath, pn, execname)):
                if LooseVersion(pn) > minv:
                    minv = LooseVersion(pn)
                    minp = os.path.join(btpath, pn, execname)
        return minp


def get_android_sdk(directory, condf=get_android_jar):
    s = open_as_text(os.path.join(directory, 'local.properties'))
    m = re.search(r'^sdk.directory\s*[=:]\s*(.*)$', s, re.MULTILINE)
    if m:
        val = m.group(1).replace('\\:', ':').replace('\\=', '=').replace('\\\\', '\\')
        if os.path.isdir(val) and condf(val):
            return val

    path = os.getenv('ANDROID_HOME')
    if path and os.path.isdir(path) and condf(path):
        return path

    path = os.getenv('ANDROID_SDK')
    if path and os.path.isdir(path) and condf(path):
        return path

    # mac
    path = os.path.expanduser('~/Library/Android/sdk')
    if path and os.path.isdir(path) and condf(path):
        return path

    # windows
    path = os.path.expanduser('~/AppData/Local/Android/sdk')
    if path and os.path.isdir(path) and condf(path):
        return path


def get_javac(directory):
    execname = os.name == 'nt' and 'javac.exe' or 'javac'
    if directory and os.path.isfile(os.path.join(directory, 'bin', execname)):
        return os.path.join(directory, 'bin', execname)

    wpath = which(execname)
    if wpath:
        return wpath

    path = os.getenv('JAVA_HOME')
    if path and is_exe(os.path.join(path, 'bin', execname)):
        return os.path.join(path, 'bin', execname)

    if os.name == 'nt':
        btpath = 'C:\\Program Files\\Java'
        if os.path.isdir(btpath):
            minv = ''
            minp = None
            for pn in os.listdir(btpath):
                path = os.path.join(btpath, pn, 'bin', execname)
                if is_exe(path):
                    if pn > minv:
                        minv = pn
                        minp = path
            return minp
    else:
        for btpath in ['/Library/Java/JavaVirtualMachines', '/System/Library/Java/JavaVirtualMachines']:
            if os.path.isdir(btpath):
                minv = ''
                minp = None
                for pn in os.listdir(btpath):
                    path = os.path.join(btpath, pn, 'Contents', 'Home', 'bin', execname)
                    if is_exe(path):
                        if pn > minv:
                            minv = pn
                            minp = path
                if minp:
                    return minp


def search_path(directory, filename):
    dir0 = filename
    if os.path.sep in filename:
        dir0 = filename[0:filename.index(os.path.sep)]
    a_list = []
    parpath = None
    for dirpath, dirnames, files in os.walk(directory):
        if re.findall(r'[/\\+]androidTest[/\\+]', dirpath) or '/.' in dirpath:
            continue
        if dir0 in dirnames:
            parpath = dirpath
            break;
    if parpath:
        for dirpath, dirnames, files in os.walk(parpath):
            if 'R.class' in files:
                print parpath
                a_list.append(parpath)
                break;

    if len(a_list) == 1:
        return a_list[0]
    elif len(a_list) > 1:
        maxt = 0
        maxd = None
        for ddir in a_list:
            lastModified = 0
            for dirpath, dirnames, files in os.walk(directory):
                for fn in files:
                    if fn.endswith('.class'):
                        lastModified = os.path.getmtime(os.path.join(dirpath, fn))
            if lastModified > maxt:
                maxt = lastModified
                maxd = ddir
        return maxd
    else:
        if os.path.sep in filename:
            filename_pre = filename[0:filename.rfind(os.path.sep)]
            print filename_pre
        return os.path.join(directory, 'debug')


def get_maven_libs(projs):
    maven_deps = []
    for proj in projs:
        sFile = open_as_text(os.path.join(proj, 'build.gradle'))
        sFile = remove_comments(sFile)
        for m in re.finditer(r'dependencies\s*\{', sFile):
            depends = balanced_braces(sFile[m.start():])
            for mvndep in re.findall(r'''compile\s+['"](.+:.+:.+)(?:@*)?['"]''', depends):
                mvndeps = mvndep.split(':')
                if not mvndeps in maven_deps:
                    maven_deps.append(mvndeps)
    return maven_deps


def get_maven_jars(libs):
    if not libs:
        return []
    jars = []
    maven_path_prefix = []
    # ~/.gralde/caches
    gradle_home = os.path.join(os.path.expanduser('~'), '.gradle', 'caches')
    for dirpath, dirnames, files in os.walk(gradle_home):
        # search in ~/.gradle/**/GROUP_ID/ARTIFACT_ID/VERSION/**/*.jar
        for mvndeps in libs:
            if mvndeps[0] in dirnames:
                dir1 = os.path.join(dirpath, mvndeps[0], mvndeps[1])
                if os.path.isdir(dir1):
                    dir2 = os.path.join(dir1, mvndeps[2])
                    if os.path.isdir(dir2):
                        maven_path_prefix.append(dir2)
                    else:
                        prefix = mvndeps[2]
                        if '+' in prefix:
                            prefix = prefix[0:prefix.index('+')]
                        maxdir = ''
                        for subd in os.listdir(dir1):
                            if subd.startswith(prefix) and subd > maxdir:
                                maxdir = subd
                        if maxdir:
                            maven_path_prefix.append(os.path.join(dir1, maxdir))
        for dirprefix in maven_path_prefix:
            if dirpath.startswith(dirprefix):
                for fn in files:
                    if fn.endswith('.jar') and not fn.startswith('.') and not fn.endswith('-sources.jar') and not fn.endswith('-javadoc.jar'):
                        jars.append(os.path.join(dirpath, fn))
                break
    return jars


def get_resource_xml(content):
    if content:
        mathrul = "attr|iD|style|string|dimen|color|array|drawable|layout|anim|integer|animator|interpolator|transition|raw"
        output = re.finditer(r'resource (0x7f[0-f]{6}).*(' + mathrul + ')\/(.+)\:.*', content)
        idsnum = []
        publicxml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" + "<resources>\n"
        idsxml = publicxml

        for match in output:
            iD = str(match.group(1))
            if iD not in idsnum:
                idsnum.append(iD)
                publicinfo = "  <public type=\"" + str(match.group(2)) + "\" name=\"" + str(match.group(3)) + "\" iD=\"" + str(match.group(1)) + "\" />\n"
                publicxml += publicinfo
                if str(match.group(2)) == "iD":
                    idinfo = "  <item type=\"iD\" name=\"" + str(match.group(3)) + "\" />\n"
                    idsxml += idinfo

        publicxml += "</resources>"
        idsxml += "</resources>"
        return (publicxml, idsxml)


def scan_port(adbpath, pnlist, projlist):
    port = 0
    prodir = None
    packagename = None
    for i in range(0, 10):
        cexec([adbpath, 'forward', 'tcp:%d' % (41128 + i), 'tcp:%d' % (41128 + i)])
        output = curl('http://127.0.0.1:%d/packagename' % (41128 + i), ignoreError=True)
        if output and output in pnlist:
            index = pnlist.index(output)  # index of this app in projlist
            state = curl('http://127.0.0.1:%d/appstate' % (41128 + i), ignoreError=True)
            if state and int(state) >= 2:
                port = 41128 + i
                prodir = projlist[index]
                packagename = output
                break
    for i in range(0, 10):
        if (41128 + i) != port:
            cexec([adbpath, 'forward', '--remove', 'tcp:%d' % (41128 + i)], callback=None)
    return port, prodir, packagename


# Get only the  resources that exists in the local project
# Fix for the "appcompat like" libs
def filter_public_xml(args, code, stdout, stderr):
    if code != 0 and re.search(r"declared here is not defined.", stderr):
        listMatches = re.findall(r"(?<=error: Public symbol ).+(?= declared here is not defined)", stderr)

        if os.path.exists(os.path.join(binresdir, "values", "public.xml")):
            publicXml = open(os.path.join(binresdir, "values", "public.xml"), "r")
            tempStr = ""
            listMatchesSplitted = []

            for mt in listMatches:
                listMatchesSplitted.append(mt.split("/"))

            for line in publicXml.readlines():
                isMatch = True
                for mt in listMatchesSplitted:
                    if line.find(mt[0]) > -1 and line.find(mt[1]) > -1:
                        isMatch = False
                        break

                if isMatch:
                    tempStr += line

            publicXml = open(os.path.join(binresdir, "values", "public.xml"), "w")
            publicXml.write(tempStr)
            publicXml.close()

        cexec(args, cexec_fail_exit, exitcode=18)
    else:
        cexec_fail_exit(args, code, stdout, stderr)


if __name__ == "__main__":

    directory = '.'
    sdkdir = None
    jdkdir = None

    starttime = time.time()

    if len(sys.argv) > 1:
        parser = argparse.ArgumentParser()
        parser.add_argument('--sdk', help='specify Android SDK path')
        parser.add_argument('--jdk', help='specify JDK path')
        parser.add_argument('project')
        args = parser.parse_args()
        if args.sdk:
            sdkdir = args.sdk
        if args.jdk:
            jdkdir = args.jdk
        if args.project:
            directory = args.project

    projlist = [i for i in list_projects(directory) if is_launchable_project(i)]

    if not sdkdir:
        sdkdir = get_android_sdk(directory)
        if not sdkdir:
            print('android sdk not found, specify in local.properties or export ANDROID_HOME')
            exit(2)

    if not projlist:
        print('no valid android project found in ' + os.path.abspath(directory))
        exit(3)

    pnlist = [package_name_fromapk(i, sdkdir) for i in projlist]
    portlist = [0 for i in pnlist]
    adbpath = get_adb(sdkdir)
    if not adbpath:
        print('adb not found in %s/platform-tools' % sdkdir)
        exit(4)
    port, directory, packagename = scan_port(adbpath, pnlist, projlist)

    if port == 0:
        # launch app
        latest_package = get_latest_packagename(projlist, sdkdir)
        if latest_package:
            cexec([adbpath, 'shell', 'monkey', '-p', latest_package, '-c', 'android.intent.category.LAUNCHER', '1'], callback=None)
            for i in range(0, 6):
                # try 6 times to wait the application launches
                port, directory, packagename = scan_port(adbpath, pnlist, projlist)
                if port:
                    break
                time.sleep(0.25)

    if port == 0:
        print('package %s not found, make sure your project is properly setup and running' % (len(pnlist) == 1 and pnlist[0] or pnlist))
        exit(5)

    is_gradle = is_gradle_project(directory)

    android_jar = get_android_jar(sdkdir)
    if not android_jar:
        print('android.jar not found !!!\nUse local.properties or set ANDROID_HOME env')
        exit(7)
    deps = deps_list(directory)
    bindir = is_gradle and os.path.join(directory, 'build', 'lcast') or os.path.join(directory, 'bin', 'lcast')

    if not os.path.exists(os.path.join(bindir, "lastBuildSrc")):  # just to initiate files if not exists
        open(os.path.join(bindir, "lastBuildSrc"), "w").write("0")

    # check if the /res and /src has changed
    lastBuild = 0
    rdir = is_gradle and os.path.join(directory, 'build', 'outputs', 'apk') or os.path.join(directory, 'bin')
    if os.path.isdir(rdir):
        for fn in os.listdir(rdir):
            if fn.endswith('.apk') and not '-androidTest' in fn:
                fpath = os.path.join(rdir, fn)
                lastBuild = max(lastBuild, os.path.getmtime(fpath))
    adeps = []
    adeps.extend(deps)
    adeps.append(directory)
    latestResModified = 0
    latestSrcModified = 0
    srcs = []
    msrclist = []
    assetdirs = []
    for dep in adeps:
        adir = asset_dir(dep)
        if adir:
            latestModified = os.path.getmtime(adir)
            for dirpath, dirnames, files in os.walk(adir):
                for dirname in dirnames:
                    if not dirname.startswith('.'):
                        latestModified = max(latestModified, os.path.getmtime(os.path.join(dirpath, dirname)))
                for fn in files:
                    if not fn.startswith('.'):
                        fpath = os.path.join(dirpath, fn)
                        latestModified = max(latestModified, os.path.getmtime(fpath))
            latestResModified = max(latestResModified, latestModified)
            if latestModified > lastBuild:
                assetdirs.append(adir)
        rdir = res_dir(dep)
        if rdir:
            for subd in os.listdir(rdir):
                if os.path.isdir(os.path.join(rdir, subd)) and isRes_Name(subd):
                    for fn in os.listdir(os.path.join(rdir, subd)):
                        fpath = os.path.join(rdir, subd, fn)
                        if os.path.isfile(fpath) and not fn.startswith('.'):
                            latestResModified = max(latestResModified, os.path.getmtime(fpath))
        (sdir, scount, smt) = src_dir2(dep, lastBuild=lastBuild, alist=msrclist)
        if sdir:
            srcs.append(sdir)
            latestSrcModified = max(latestSrcModified, smt)

    resModified = latestResModified > lastBuild
    srcModified = latestSrcModified > lastBuild and round(latestSrcModified * 100) > round(float(open(os.path.join(bindir, "lastBuildSrc"), "r").read()) * 100)

    targets = ''
    if resModified and srcModified:
        targets = 'both /res and /src'
        open(os.path.join(bindir, "lastBuildSrc"), "w").write(str(latestSrcModified))
    elif resModified:
        targets = '/res'
    elif srcModified:
        targets = '/src'
        open(os.path.join(bindir, "lastBuildSrc"), "w").write(str(latestSrcModified))
    else:
        print('%s has no /res or /src changes' % (packagename))
        open(os.path.join(bindir, "lastBuildSrc"), "w").write("0")
        exit(0)

    if is_gradle:
        print('cast %s:%d as gradle project with %s changed (v%s)' % (packagename, port, targets, __version__))
    else:
        print('cast %s:%d as eclipse project with %s changed (v%s)' % (packagename, port, targets, __version__))

    # prepare to reset
    if srcModified:
        curl('http://127.0.0.1:%d/pcast' % port, ignoreError=True)

    if resModified:
        binresdir = os.path.join(bindir, 'res')
        if not os.path.exists(os.path.join(binresdir, 'values')):
            os.makedirs(os.path.join(binresdir, 'values'))

        data = curl('http://127.0.0.1:%d/ids.xml' % port, exitcode=8)
        with open(os.path.join(binresdir, 'values/ids.xml'), 'w') as fp:
            fp.write(data)
        data = curl('http://127.0.0.1:%d/public.xml' % port, exitcode=9)
        with open(os.path.join(binresdir, 'values/public.xml'), 'w') as fp:
            fp.write(data)

        # Get the assets path
        apk_path = get_apk_path(directory)
        if apk_path:
            assets_path = os.path.join(bindir, "assets")
            if os.path.isdir(assets_path):
                shutil.rmtree(assets_path)
            get_asset_from_apk(apk_path, bindir)
        aaptpath = get_aapt(sdkdir)
        if not aaptpath:
            print('aapt not found in %s/build-tools' % sdkdir)
            exit(10)
        aaptargs = [aaptpath, 'package', '-f', '--auto-add-overlay', '-F', os.path.join(bindir, 'res.zip')]
        aaptargs.append('-S')
        aaptargs.append(binresdir)
        rdir = res_dir(directory)
        if rdir:
            aaptargs.append('-S')
            aaptargs.append(rdir)
        for dep in reversed(deps):
            rdir = res_dir(dep)
            if rdir:
                aaptargs.append('-S')
                aaptargs.append(rdir)
        if is_gradle:
            for dep in reversed(list_aar_projects(directory, deps)):
                aaptargs.append('-S')
                aaptargs.append(dep)
        for asset_dir in assetdirs:
            aaptargs.append('-A')
            aaptargs.append(asset_dir)
        if os.path.isdir(assets_path):
            aaptargs.append('-A')
            aaptargs.append(assets_path)
        aaptargs.append('-M')
        aaptargs.append(manifest_path(directory))
        for andr_jar in android_jar:
            aaptargs.append('-I')
            aaptargs.append(andr_jar)

        cexec(aaptargs, filter_public_xml, exitcode=18)

        with open(os.path.join(bindir, 'res.zip'), 'rb') as fp:
            curl('http://127.0.0.1:%d/pushres' % port, body=fp.read(), exitcode=11)

    if srcModified:
        vmversion = curl('http://127.0.0.1:%d/vmversion' % port, ignoreError=True)
        if vmversion == None:
            vmversion = ''
        if vmversion.startswith('1') or vmversion.startswith('2'):
            javac = get_javac(jdkdir)
            if not javac:
                print('javac is required to compile java code, config your PATH to include javac')
                exit(12)

            launcher = curl('http://127.0.0.1:%d/launcher' % port, exitcode=13)

            classpath = android_jar
            for dep in adeps:
                dlib = lib_dir(dep)
                if dlib:
                    for fjar in os.listdir(dlib):
                        if fjar.endswith('.jar'):
                            classpath.append(os.path.join(dlib, fjar))
            if is_gradle:
                # jars from maven cache
                maven_libs = get_maven_libs(adeps)
                maven_libs_cache_file = os.path.join(bindir, 'cache-javac-maven.json')
                maven_libs_cache = {}
                if os.path.isfile(maven_libs_cache_file):
                    try:
                        with open(maven_libs_cache_file, 'r') as fp:
                            maven_libs_cache = json.load(fp)
                    except:
                        pass
                if maven_libs_cache.get('version') != 1 or not maven_libs_cache.get('from') or sorted(maven_libs_cache['from']) != sorted(maven_libs):
                    if os.path.isfile(maven_libs_cache_file):
                        os.remove(maven_libs_cache_file)
                    maven_libs_cache = {}
                maven_jars = []
                if maven_libs_cache:
                    maven_jars = maven_libs_cache.get('jars')
                elif maven_libs:
                    maven_jars = get_maven_jars(maven_libs)
                    cache = {'version': 1, 'from': maven_libs, 'jars': maven_jars}
                    try:
                        with open(maven_libs_cache_file, 'w') as fp:
                            json.dump(cache, fp)
                    except:
                        pass
                if maven_jars:
                    classpath.extend(maven_jars)
                # aars from exploded-aar
                darr = os.path.join(directory, 'build', 'intermediates', 'exploded-aar')
                # TODO: use the max version
                for dirpath, dirnames, files in os.walk(darr):
                    if re.findall(r'[/\\+]androidTest[/\\+]', dirpath) or '/.' in dirpath:
                        continue
                    for fn in files:
                        if fn.endswith('.jar'):
                            classpath.append(os.path.join(dirpath, fn))
                # R.class
                classesdir = search_path(os.path.join(directory, 'build', 'intermediates', 'classes'), launcher and launcher.replace('.', os.path.sep) + '.class' or '$')
                classpath.append(classesdir)
            else:
                # R.class
                classpath.append(os.path.join(directory, 'bin', 'classes'))

            binclassesdir = os.path.join(bindir, 'classes')
            shutil.rmtree(binclassesdir, ignore_errors=True)
            os.makedirs(binclassesdir)

            javacargs = [javac, '-target', '1.7', '-source', '1.7', '-encoding', 'UTF-8']
            javacargs.append('-cp')
            javacargs.append(os.pathsep.join(classpath))
            javacargs.append('-d')
            javacargs.append(binclassesdir)
            javacargs.append('-sourcepath')
            javacargs.append(os.pathsep.join(srcs))
            javacargs.extend(msrclist)


            # remove all cache if javac fail
            def remove_cache_and_exit(args, code, stdout, stderr):
                if code:
                    maven_libs_cache_file = os.path.join(bindir, 'cache-javac-maven.json')
                    if os.path.isfile(maven_libs_cache_file):
                        os.remove(maven_libs_cache_file)
                cexec_fail_exit(args, code, stdout, stderr)


            cexec(javacargs, callback=remove_cache_and_exit, exitcode=19)

            dxpath = get_dx(sdkdir)
            if not dxpath:
                print('dx not found in %s/build-tools' % sdkdir)
                exit(14)
            dxoutput = os.path.join(bindir, 'classes.dex')
            if os.path.isfile(dxoutput):
                os.remove(dxoutput)
            addPath = None
            if os.name == 'nt':
                # fix system32 java.exe issue
                addPath = os.path.abspath(os.path.join(javac, os.pardir))
            cexec([dxpath, '--dex', '--output=%s' % dxoutput, binclassesdir], addPath=addPath, exitcode=20)

            with open(dxoutput, 'rb') as fp:
                curl('http://127.0.0.1:%d/pushdex' % port, body=fp.read(), exitcode=15)

        else:
            if is_gradle:
                print('LayoutCast library out of date, please sync your project with gradle')
            else:
                print('libs/lcast.jar is out of date, please update')

    curl('http://127.0.0.1:%d/lcast' % port, ignoreError=True)

    cexec([adbpath, 'forward', '--remove', 'tcp:%d' % port], callback=None)

    elapsetime = time.time() - starttime
    print('finished in %dms' % (elapsetime * 1000))