package com.jeremy.plugin

import org.gradle.api.Plugin
import org.gradle.api.Project

class DemoPlugin implements Plugin<Project> {

    @Override
    void apply(Project project) {

        project.task('test_task') << {
            println 'hello, world!'
        }
    }
}

/**
 * Aspect representing the cross cutting-concern: Method and Constructor Tracing.
 */
@Aspect
public class TraceExecuteTimeAspect {

    private static final String TAG_TRACE_EXE_TIME = "TraceExecuteTime";


    @Pointcut("execution(@com.jeremy.probe_annotations.annotation.TraceExecuteTime * *(..))")
    public void methodAnnotatedTraceExecuteTime() {
    }

    @Pointcut("execution(@com.jeremy.probe_annotations.annotation.TraceExecuteTime *.new(..))")
    public void constructorAnnotatedTraceExecuteTime() {
    }

    @Around("methodAnnotatedTraceExecuteTime() || constructorAnnotatedTraceExecuteTime()")
    public Object weaveJoinPointTraceExecuteTime(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        SpendTimeWatcher spendTimeWatcher = new SpendTimeWatcher();
        spendTimeWatcher.start();
        Object result = joinPoint.proceed();
        spendTimeWatcher.stop();
        Log.d(TAG_TRACE_EXE_TIME, buildMessageTraceExeTime(methodSignature.getDeclaringType().getName(),
                methodSignature.getName(),
                spendTimeWatcher.getTotalTimeMillis()));
        return result;
    }

    private static String buildMessageTraceExeTime(String className, String methodName, long methodDuration) {
        return new StringBuilder()
                .append("Spend time: ")
                .append(methodDuration)
                .append(" ms")
                .append("\n --> ")
                .append("during execute method: ")
                .append(methodName)
                .append("()")
                .append("\n --> ")
                .append("in class: ")
                .append(className)
                .toString();
    }
}

@Aspect
public class TraceReturnAspect {

    private static final String TAG_TRACE_RETURN = "TraceReturn";

    @Pointcut("execution(@com.jeremy.probe_annotations.annotation.TraceReturn * *(..))")
    public void methodAnnotatedTraceReturn() {
    }

    @Around("methodAnnotatedTraceReturn()")
    public Object weaveJoinPointTraceReturn(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Object result = joinPoint.proceed();
        Log.d(TAG_TRACE_RETURN, buildMessageTraceReturn(methodSignature.getDeclaringType().getName(),
                methodSignature.getName(),
                result));
        return result;
    }

    private static String buildMessageTraceReturn(String className, String methodName, Object returnValue) {
        return new StringBuilder()
                .append("Return value: ")
                .append(returnValue)
                .append("\n --> ")
                .append("by method: ")
                .append(methodName)
                .append("()")
                .append("\n --> ")
                .append("in class: ")
                .append(className)
                .toString();
    }
}

package com.jeremy.probe_compiler

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.tasks.compile.JavaCompile

class ProbePlugin implements Plugin<Project> {

    @Override
    void apply(Project project) {
        project.android.applicationVariants.all { variant ->

            println("hello ProbePlugin")

            if (!variant.buildType.isDebuggable()) {
                project.logger.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
                return;
            }

            JavaCompile javaCompile = variant.javaCompile
            javaCompile.doLast {
                def log = project.logger
                String[] args = ["-showWeaveInfo",
                                 "-1.7",
                                 "-inpath", javaCompile.destinationDir.toString(),
                                 "-aspectpath", javaCompile.classpath.asPath,
                                 "-d", javaCompile.destinationDir.toString(),
                                 "-classpath", javaCompile.classpath.asPath,
                                 "-bootclasspath", project.android.bootClasspath.join(File.pathSeparator)]
                def argsStr = Arrays.toString(args)
                println("begin apply ProbePlugin")
                println("execute aspectj args: " + argsStr)
                log.debug "ajc args: " + argsStr

                MessageHandler handler = new MessageHandler(true);
                new Main().run(args, handler);
                for (IMessage message : handler.getMessages(null, true)) {
                    switch (message.getKind()) {
                        case IMessage.ABORT:
                        case IMessage.ERROR:
                        case IMessage.FAIL:
                            log.error message.message, message.thrown
                            break;
                        case IMessage.WARNING:
                            log.warn message.message, message.thrown
                            break;
                        case IMessage.INFO:
                            log.info message.message, message.thrown
                            break;
                        case IMessage.DEBUG:
                            log.debug message.message, message.thrown
                            break;
                    }
                }
            }
        }
    }
}