Merge "Merge "Fix: some flagged APIs are not recorded." into main am:...

package android.platform.coverage

import com.android.tools.metalava.model.ClassItem

import com.android.tools.metalava.model.MethodItem

import com.android.tools.metalava.model.text.ApiFile

import java.io.File

import java.io.FileWriter

/** Usage: extract-flagged-apis <api text file> <output .pb file> */

fun main(args: Array<String>) {

    var cb = ApiFile.parseApi(listOf(File(args[0])))

    var builder = FlagApiMap.newBuilder()

    val cb = ApiFile.parseApi(listOf(File(args[0])))

    val builder = FlagApiMap.newBuilder()

    for (pkg in cb.getPackages().packages) {

        var packageName = pkg.qualifiedName()

        val packageName = pkg.qualifiedName()

        pkg.allClasses()

            .filter { it.methods().size > 0 }

            .forEach {

                for (method in it.methods()) {

                    val flagValue =

                extractFlaggedApisFromClass(it, it.methods(), packageName, builder)

                extractFlaggedApisFromClass(it, it.constructors(), packageName, builder)

            }

    }

    val flagApiMap = builder.build()

    FileWriter(args[1]).use { it.write(flagApiMap.toString()) }

}

fun extractFlaggedApisFromClass(

    classItem: ClassItem,

    methods: List<MethodItem>,

    packageName: String,

    builder: FlagApiMap.Builder

) {

    val classFlag =

        classItem.modifiers

            .findAnnotation("android.annotation.FlaggedApi")

            ?.findAttribute("value")

            ?.value

            ?.value() as? String

    for (method in methods) {

        val methodFlag =

            method.modifiers

                .findAnnotation("android.annotation.FlaggedApi")

                ?.findAttribute("value")

                ?.value

                            ?.value()

                    if (flagValue != null && flagValue is String) {

                        var api =

                ?.value() as? String

                ?: classFlag

        val api =

            JavaMethod.newBuilder()

                .setPackageName(packageName)

                                .setClassName(it.fullName())

                .setClassName(classItem.fullName())

                .setMethodName(method.name())

        for (param in method.parameters()) {

            api.addParameters(param.type().toTypeString())

        }

                        if (builder.containsFlagToApi(flagValue)) {

                            var updatedApis =

                                builder

                                    .getFlagToApiOrThrow(flagValue)

                                    .toBuilder()

                                    .addJavaMethods(api)

                                    .build()

                            builder.putFlagToApi(flagValue, updatedApis)

                        } else {

                            var apis = FlaggedApis.newBuilder().addJavaMethods(api).build()

                            builder.putFlagToApi(flagValue, apis)

                        }

        if (methodFlag != null) {

            addFlaggedApi(builder, api, methodFlag)

        }

    }

}

fun addFlaggedApi(builder: FlagApiMap.Builder, api: JavaMethod.Builder, flag: String) {

    if (builder.containsFlagToApi(flag)) {

        val updatedApis = builder.getFlagToApiOrThrow(flag).toBuilder().addJavaMethods(api).build()

        builder.putFlagToApi(flag, updatedApis)

    } else {

        val apis = FlaggedApis.newBuilder().addJavaMethods(api).build()

        builder.putFlagToApi(flag, apis)

    }

    val flagApiMap = builder.build()

    FileWriter(args[1]).use { it.write(flagApiMap.toString()) }

}