Baixe o app para aproveitar ainda mais
Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original
Aula20180326/.gitignore *.iml .gradle /local.properties /.idea/workspace.xml /.idea/libraries .DS_Store /build /captures .externalNativeBuild Aula20180326/app/.gitignore /build Aula20180326/app/build.gradle apply plugin: 'com.android.application' android { compileSdkVersion 26 defaultConfig { applicationId "com.example.administrador.aula20180326" minSdkVersion 15 targetSdkVersion 26 versionCode 1 versionName "1.0" testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" } buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } } dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) implementation 'com.android.support.constraint:constraint-layout:1.0.2' testImplementation 'junit:junit:4.12' androidTestImplementation 'com.android.support.test:runner:1.0.1' androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1' } Aula20180326/app/proguard-rules.pro # Add project specific ProGuard rules here. # You can control the set of applied configuration files using the # proguardFiles setting in build.gradle. # # For more details, see # http://developer.android.com/guide/developing/tools/proguard.html # If your project uses WebView with JS, uncomment the following # and specify the fully qualified class name to the JavaScript interface # class: #-keepclassmembers class fqcn.of.javascript.interface.for.webview { # public *; #} # Uncomment this to preserve the line number information for # debugging stack traces. #-keepattributes SourceFile,LineNumberTable # If you keep the line number information, uncomment this to # hide the original source file name. #-renamesourcefileattribute SourceFile Aula20180326/app/src/androidTest/java/com/example/administrador/aula20180326/ExampleInstrumentedTest.java package com.example.administrador.aula20180326; import android.content.Context; import android.support.test.InstrumentationRegistry; import android.support.test.runner.AndroidJUnit4; import org.junit.Test; import org.junit.runner.RunWith; import static org.junit.Assert.*; /** * Instrumented test, which will execute on an Android device. * * @see <a href="http://d.android.com/tools/testing">Testing documentation</a> */ @RunWith(AndroidJUnit4.class) public class ExampleInstrumentedTest { @Test public void useAppContext() throws Exception { // Context of the app under test. Context appContext = InstrumentationRegistry.getTargetContext(); assertEquals("com.example.administrador.aula20180326", appContext.getPackageName()); } } Aula20180326/app/src/main/AndroidManifest.xml Aula20180326/app/src/main/java/com/example/administrador/aula20180326/Pedido.java package com.example.administrador.aula20180326; import android.app.Activity; import android.content.Intent; import android.os.Bundle; import android.view.View; import android.widget.Button; import android.widget.TextView; public class Pedido extends Activity implements View.OnClickListener{ private Button btnVoltar; private TextView txtPedido; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_pedido); btnVoltar = (Button)findViewById(R.id.btnVoltar); txtPedido = (TextView)findViewById(R.id.txtPedido); btnVoltar.setOnClickListener(this); //RECEBER dados da Atividade Principal Intent it = getIntent(); String tipo = it.getStringExtra("tipo"); String sabor = it.getStringExtra("sabor"); int quantidade = it.getIntExtra("quantidade",0); double vltotal = 0; if (tipo.equals("Cone")){ vltotal = quantidade * 2.50; }else if (tipo.equals("Cone Duplo")) { vltotal = quantidade * 4.50; }else if (tipo.equals("Picolé")) { vltotal = quantidade * 1.50; }else{ vltotal = quantidade * 8.00; } //Exibir o resultado StringBuilder sb = new StringBuilder(); sb.append("Tipo = ").append(tipo).append("\n"); sb.append("Sabor= ").append(sabor).append("\n"); sb.append("Qtde.= ").append(quantidade).append("\n"); sb.append("\n").append("\n"); sb.append("Vl.Total= ").append(String.format("%.2f",vltotal)).append("\n"); txtPedido.setText(sb.toString()); } @Override public void onClick(View v) { if(v.getId() == R.id.btnVoltar){ onBackPressed(); } } } Aula20180326/app/src/main/java/com/example/administrador/aula20180326/Principal.java package com.example.administrador.aula20180326; import android.app.Activity; import android.app.AlertDialog; import android.content.DialogInterface; import android.content.Intent; import android.os.Bundle; import android.view.View; import android.widget.ArrayAdapter; import android.widget.Button; import android.widget.EditText; import android.widget.RadioButton; import android.widget.RadioGroup; import android.widget.Spinner; public class Principal extends Activity implements View.OnClickListener { private Spinner spTipo; private RadioGroup rdgSabor; private EditText edtQuantidade; private Button btnFinalizar; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_principal); spTipo = (Spinner)findViewById(R.id.spTipo); rdgSabor = (RadioGroup)findViewById(R.id.rdgSabor); edtQuantidade = (EditText)findViewById(R.id.edtQuantidade); btnFinalizar = (Button)findViewById(R.id.btnFinalizar); btnFinalizar.setOnClickListener(this); carregarListaTipos(); } private void carregarListaTipos(){ String tipos[] = {"Cone","Cone Duplo","Picolé","Sundae"}; ArrayAdapter<String> adp = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, tipos); adp.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); spTipo.setAdapter(adp); } @Override public void onClick(View v) { if(v.getId() == R.id.btnFinalizar){ //Caixa de Diálogo AlertDialog.Builder dlg = new AlertDialog.Builder(this); dlg.setTitle(R.string.app_name); dlg.setMessage("Tem certeza que deseja finalizar o pedido?"); dlg.setNegativeButton("Sim",new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { abrirAtividade(); } }); dlg.setPositiveButton("Não",null); dlg.show(); } } private void abrirAtividade(){ //Definir Parâmetros String tipo = spTipo.getSelectedItem().toString(); int sabor_id = rdgSabor.getCheckedRadioButtonId(); RadioButton rdb = (RadioButton)findViewById(sabor_id); String sabor = rdb.getText().toString(); int qtde = 0; if (edtQuantidade.getText().length()> 0) { qtde = Integer.parseInt(edtQuantidade.getText().toString()); } //Criar Intent Intent it = new Intent(this,Pedido.class); it.putExtra("tipo",tipo); it.putExtra("sabor",sabor); it.putExtra("quantidade",qtde); startActivity(it); } } Aula20180326/app/src/main/res/drawable/ic_launcher_background.xml Aula20180326/app/src/main/res/drawable-v24/ic_launcher_foreground.xml Aula20180326/app/src/main/res/layout/activity_pedido.xml Aula20180326/app/src/main/res/layout/activity_principal.xml Aula20180326/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml Aula20180326/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml Aula20180326/app/src/main/res/mipmap-hdpi/ic_launcher.png Aula20180326/app/src/main/res/mipmap-hdpi/ic_launcher_round.png Aula20180326/app/src/main/res/mipmap-mdpi/ic_launcher.png Aula20180326/app/src/main/res/mipmap-mdpi/ic_launcher_round.png Aula20180326/app/src/main/res/mipmap-xhdpi/ic_launcher.png Aula20180326/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png Aula20180326/app/src/main/res/mipmap-xxhdpi/ic_launcher.png Aula20180326/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png Aula20180326/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png Aula20180326/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png Aula20180326/app/src/main/res/values/colors.xml #3F51B5 #303F9F #FF4081 Aula20180326/app/src/main/res/values/strings.xml Sorveteria do João Configurações Tipo Sabor Quantidade Pedido Chocolate Creme Flocos Morango Napolitano Finalizar Voltar Aula20180326/app/src/main/res/values/styles.xml Aula20180326/app/src/test/java/com/example/administrador/aula20180326/ExampleUnitTest.java package com.example.administrador.aula20180326; import org.junit.Test; import static org.junit.Assert.*; /** * Example local unit test, which will execute on the development machine (host). * * @see <a href="http://d.android.com/tools/testing">Testing documentation</a> */ public class ExampleUnitTest { @Test public void addition_isCorrect() throws Exception { assertEquals(4, 2 + 2); } } Aula20180326/build.gradle // Top-level build file where you can add configuration options common to all sub-projects/modules. buildscript { repositories { google() jcenter() } dependencies { classpath 'com.android.tools.build:gradle:3.0.1' // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files } } allprojects { repositories { google() jcenter() } } task clean(type: Delete) { delete rootProject.buildDir } Aula20180326/gradle/wrapper/gradle-wrapper.jar META-INF/MANIFEST.MF Manifest-Version: 1.0 Implementation-Title: Gradle Implementation-Version: 2.10 org/gradle/wrapper/Download$1.class package org.gradle.wrapper; synchronized class Download$1 { } org/gradle/wrapper/Download$SystemPropertiesProxyAuthenticator.class package org.gradle.wrapper; synchronized class Download$SystemPropertiesProxyAuthenticator extends java.net.Authenticator { private void Download$SystemPropertiesProxyAuthenticator(); protected java.net.PasswordAuthentication getPasswordAuthentication(); } org/gradle/wrapper/IDownload.class package org.gradle.wrapper; public abstract interface IDownload { public abstract void download(java.net.URI, java.io.File) throws Exception; } org/gradle/wrapper/GradleUserHomeLookup.class package org.gradle.wrapper; public synchronized class GradleUserHomeLookup { public static final String DEFAULT_GRADLE_USER_HOME; public static final String GRADLE_USER_HOME_PROPERTY_KEY = gradle.user.home; public static final String GRADLE_USER_HOME_ENV_KEY = GRADLE_USER_HOME; public void GradleUserHomeLookup(); public static java.io.File gradleUserHome(); static void <clinit>(); } org/gradle/wrapper/ExclusiveFileAccessManager.class package org.gradle.wrapper; public synchronized class ExclusiveFileAccessManager { public static final String LOCK_FILE_SUFFIX = .lck; private final int timeoutMs; private final int pollIntervalMs; public void ExclusiveFileAccessManager(int, int); public Object access(java.io.File, java.util.concurrent.Callable) throws Exception; private static void maybeCloseQuietly(java.io.Closeable); } org/gradle/wrapper/WrapperConfiguration.class package org.gradle.wrapper; public synchronized class WrapperConfiguration { private java.net.URI distribution; private String distributionBase; private String distributionPath; private String distributionSha256Sum; private String zipBase; private String zipPath; public void WrapperConfiguration(); public java.net.URI getDistribution(); public void setDistribution(java.net.URI); public String getDistributionBase(); public void setDistributionBase(String); public String getDistributionPath(); public void setDistributionPath(String); public String getDistributionSha256Sum(); public void setDistributionSha256Sum(String); public String getZipBase(); public void setZipBase(String); public String getZipPath(); public void setZipPath(String); } org/gradle/wrapper/SystemPropertiesHandler.class package org.gradle.wrapper; public synchronized class SystemPropertiesHandler { public void SystemPropertiesHandler(); public static java.util.Map getSystemProperties(java.io.File); } org/gradle/wrapper/Logger.class package org.gradle.wrapper; public synchronized class Logger implements Appendable { private final boolean quiet; public void Logger(boolean); public void log(String); public Appendable append(CharSequence); public Appendable append(CharSequence, int, int); public Appendable append(char); } org/gradle/wrapper/PathAssembler.class package org.gradle.wrapper; public synchronized class PathAssembler { public static final String GRADLE_USER_HOME_STRING = GRADLE_USER_HOME; public static final String PROJECT_STRING = PROJECT; private java.io.File gradleUserHome; public void PathAssembler(); public void PathAssembler(java.io.File); public PathAssembler$LocalDistribution getDistribution(WrapperConfiguration); private String rootDirName(String, WrapperConfiguration); private String getHash(String); private String removeExtension(String); private String getDistName(java.net.URI); private java.io.File getBaseDir(String); } org/gradle/wrapper/Install.class package org.gradle.wrapper; public synchronized class Install { public static final String DEFAULT_DISTRIBUTION_PATH = wrapper/dists; private final Logger logger; private final IDownload download; private final PathAssembler pathAssembler; private final ExclusiveFileAccessManager exclusiveFileAccessManager; public void Install(Logger, IDownload, PathAssembler); public java.io.File createDist(WrapperConfiguration) throws Exception; private String calculateSha256Sum(java.io.File) throws Exception; private java.io.File getAndVerifyDistributionRoot(java.io.File, String) throws Exception; private void verifyDownloadChecksum(String, java.io.File, String) throws Exception; private java.util.List listDirs(java.io.File); private void setExecutablePermissions(java.io.File); private boolean isWindows(); private boolean deleteDir(java.io.File); private void unzip(java.io.File, java.io.File) throws java.io.IOException; private void copyInputStream(java.io.InputStream, java.io.OutputStream) throws java.io.IOException; } org/gradle/wrapper/BootstrapMainStarter.class package org.gradle.wrapper; public synchronized class BootstrapMainStarter { public void BootstrapMainStarter(); public void start(String[], java.io.File) throws Exception; private java.io.File findLauncherJar(java.io.File); } org/gradle/wrapper/WrapperExecutor.class package org.gradle.wrapper; public synchronized class WrapperExecutor { public static final String DISTRIBUTION_URL_PROPERTY = distributionUrl; public static final String DISTRIBUTION_BASE_PROPERTY = distributionBase; public static final String DISTRIBUTION_PATH_PROPERTY = distributionPath; public static final String DISTRIBUTION_SHA_256_SUM = distributionSha256Sum; public static final String ZIP_STORE_BASE_PROPERTY = zipStoreBase; public static final String ZIP_STORE_PATH_PROPERTY = zipStorePath; private final java.util.Properties properties; private final java.io.File propertiesFile; private final Appendable warningOutput; private final WrapperConfiguration config; public static WrapperExecutor forProjectDirectory(java.io.File, Appendable); public static WrapperExecutor forWrapperPropertiesFile(java.io.File, Appendable); void WrapperExecutor(java.io.File, java.util.Properties, Appendable); private java.net.URI prepareDistributionUri() throws java.net.URISyntaxException; private java.net.URI readDistroUrl() throws java.net.URISyntaxException; private java.net.URI readDistroUrlDeprecatedWay() throws java.net.URISyntaxException; private static void loadProperties(java.io.File, java.util.Properties) throws java.io.IOException; public java.net.URI getDistribution(); public WrapperConfiguration getConfiguration(); public void execute(String[], Install, BootstrapMainStarter) throws Exception; private String getProperty(String); private String getProperty(String, String); private String getProperty(String, String, boolean); private String reportMissingProperty(String); } org/gradle/wrapper/GradleWrapperMain.class package org.gradle.wrapper; public synchronized class GradleWrapperMain { public static final String GRADLE_USER_HOME_OPTION = g; public static final String GRADLE_USER_HOME_DETAILED_OPTION = gradle-user-home; public static final String GRADLE_QUIET_OPTION = q; public static final String GRADLE_QUIET_DETAILED_OPTION = quiet; public void GradleWrapperMain(); public static void main(String[]) throws Exception; private static void addSystemProperties(java.io.File, java.io.File); private static java.io.File rootDir(java.io.File); private static java.io.File wrapperProperties(java.io.File); private static java.io.File wrapperJar(); static String wrapperVersion(); private static java.io.File gradleUserHome(org.gradle.cli.ParsedCommandLine); private static Logger logger(org.gradle.cli.ParsedCommandLine); } org/gradle/wrapper/Install$1.class package org.gradle.wrapper; synchronized class Install$1 implements java.util.concurrent.Callable { void Install$1(Install, java.io.File, java.io.File, java.net.URI, WrapperConfiguration, String); public java.io.File call() throws Exception; } org/gradle/wrapper/PathAssembler$LocalDistribution.class package org.gradle.wrapper; public synchronized class PathAssembler$LocalDistribution { private final java.io.File distZip; private final java.io.File distDir; public void PathAssembler$LocalDistribution(PathAssembler, java.io.File, java.io.File); public java.io.File getDistributionDir(); public java.io.File getZipFile(); } org/gradle/wrapper/Download.class package org.gradle.wrapper; public synchronized class Download implements IDownload { private static final int PROGRESS_CHUNK = 20000; private static final int BUFFER_SIZE = 10000; private final Logger logger; private final String applicationName; private final String applicationVersion; public void Download(Logger, String, String); private void configureProxyAuthentication(); public void download(java.net.URI, java.io.File) throws Exception; private void downloadInternal(java.net.URI, java.io.File) throws Exception; private String calculateUserAgent(); } gradle-wrapper-classpath.properties #module definition #Mon Dec 21 22:16:44 CET 2015 projects=gradle-cli runtime= build-receipt.properties buildNumber=none buildTimestamp=20151221211504+0000 commitId=276bdcded730f53aa8c11b479986aafa58e124a6 hostname=dev1.gradle.org isSnapshot=false javaVersion=1.7.0_02 osName=Linux osVersion=3.13.0-62-generic project=gradle rcNumber= username=tcagent1 versionBase=2.10 versionNumber=2.10 org/gradle/cli/AbstractCommandLineConverter.class package org.gradle.cli; public abstract synchronized class AbstractCommandLineConverter implements CommandLineConverter { public void AbstractCommandLineConverter(); public Object convert(Iterable, Object) throws CommandLineArgumentException; } org/gradle/cli/CommandLineParser$1.class package org.gradle.cli; synchronized class CommandLineParser$1 { } org/gradle/cli/CommandLineParser$MissingOptionArgState.class package org.gradle.cli; synchronized class CommandLineParser$MissingOptionArgState extends CommandLineParser$ParserState { private final CommandLineParser$OptionParserState option; private void CommandLineParser$MissingOptionArgState(CommandLineParser$OptionParserState); public boolean maybeStartOption(String); public CommandLineParser$OptionParserState onStartOption(String, String); public CommandLineParser$ParserState onNonOption(String); public void onCommandLineEnd(); } org/gradle/cli/CommandLineParser$OptionStringComparator.class package org.gradle.cli; final synchronized class CommandLineParser$OptionStringComparator implements java.util.Comparator { private void CommandLineParser$OptionStringComparator(); public int compare(String, String); } org/gradle/cli/CommandLineArgumentException.class package org.gradle.cli; public synchronized class CommandLineArgumentException extends RuntimeException { public void CommandLineArgumentException(String); public void CommandLineArgumentException(String, Throwable); } org/gradle/cli/CommandLineParser$KnownOptionParserState.class package org.gradle.cli; synchronized class CommandLineParser$KnownOptionParserState extends CommandLineParser$OptionParserState { private final CommandLineParser$OptionString optionString; private final CommandLineOption option; private final ParsedCommandLine commandLine; private final CommandLineParser$ParserState state; private final java.util.List values; private void CommandLineParser$KnownOptionParserState(CommandLineParser, CommandLineParser$OptionString, CommandLineOption, ParsedCommandLine, CommandLineParser$ParserState); public CommandLineParser$ParserState onArgument(String); public CommandLineParser$ParserState onStartNextArg(); public boolean getHasArgument(); public CommandLineParser$ParserState onComplete(); } org/gradle/cli/CommandLineParser$OptionComparator.class package org.gradle.cli; final synchronized class CommandLineParser$OptionComparator implements java.util.Comparator { private void CommandLineParser$OptionComparator(); public int compare(CommandLineOption, CommandLineOption); } org/gradle/cli/CommandLineParser$UnknownOptionParserState.class package org.gradle.cli; synchronized class CommandLineParser$UnknownOptionParserState extends CommandLineParser$OptionParserState { private final CommandLineParser$ParserState state; private final String arg; private final ParsedCommandLine commandLine; private void CommandLineParser$UnknownOptionParserState(String, ParsedCommandLine, CommandLineParser$ParserState); public boolean getHasArgument(); public CommandLineParser$ParserState onStartNextArg(); public CommandLineParser$ParserState onArgument(String); public CommandLineParser$ParserState onComplete(); } org/gradle/cli/CommandLineOption.class package org.gradle.cli; public synchronized class CommandLineOption { private final java.util.Set options; private Class argumentType; private String description; private String deprecationWarning; private boolean incubating; private final java.util.Set groupWith; public void CommandLineOption(Iterable); public java.util.Set getOptions(); public CommandLineOption hasArgument(Class); public CommandLineOption hasArgument(); public CommandLineOption hasArguments(); public String getDescription(); public CommandLineOption hasDescription(String); public boolean getAllowsArguments(); public boolean getAllowsMultipleArguments(); public CommandLineOption deprecated(String); public CommandLineOption incubating(); public String getDeprecationWarning(); java.util.Set getGroupWith(); void groupWith(java.util.Set); } org/gradle/cli/CommandLineParser$OptionParserState.class package org.gradle.cli; abstract synchronized class CommandLineParser$OptionParserState { private void CommandLineParser$OptionParserState(); public abstract CommandLineParser$ParserState onStartNextArg(); public abstract CommandLineParser$ParserState onArgument(String); public abstract boolean getHasArgument(); public abstract CommandLineParser$ParserState onComplete(); } org/gradle/cli/ParsedCommandLine.class package org.gradle.cli; public synchronized class ParsedCommandLine { private final java.util.Map optionsByString; private final java.util.Set presentOptions; private final java.util.Set removedOptions; private final java.util.List extraArguments; void ParsedCommandLine(Iterable); public String toString(); private String quoteAndJoin(Iterable); public boolean hasOption(String); public boolean hadOptionRemoved(String); public boolean hasAnyOption(java.util.Collection); public ParsedCommandLineOption option(String); public java.util.List getExtraArguments(); void addExtraValue(String); ParsedCommandLineOption addOption(String, CommandLineOption); void removeOption(CommandLineOption); } org/gradle/cli/ProjectPropertiesCommandLineConverter.class package org.gradle.cli; public synchronized class ProjectPropertiesCommandLineConverter extends AbstractPropertiesCommandLineConverter { public void ProjectPropertiesCommandLineConverter(); protected String getPropertyOption(); protected String getPropertyOptionDetailed(); protected String getPropertyOptionDescription(); } org/gradle/cli/CommandLineParser$CaseInsensitiveStringComparator.class package org.gradle.cli; final synchronized class CommandLineParser$CaseInsensitiveStringComparator implements java.util.Comparator { private void CommandLineParser$CaseInsensitiveStringComparator(); public int compare(String, String); } org/gradle/cli/CommandLineParser.class package org.gradle.cli; public synchronized class CommandLineParser { private static final java.util.regex.Pattern OPTION_NAME_PATTERN; private java.util.Map optionsByString; private boolean allowMixedOptions; private boolean allowUnknownOptions; private final java.io.PrintWriter deprecationPrinter; public void CommandLineParser(); public void CommandLineParser(java.io.Writer); public transient ParsedCommandLine parse(String[]) throws CommandLineArgumentException; public ParsedCommandLine parse(Iterable) throws CommandLineArgumentException; public CommandLineParser allowMixedSubcommandsAndOptions(); public CommandLineParser allowUnknownOptions(); public transient CommandLineParser allowOneOf(String[]); public void printUsage(Appendable); private static String join(java.util.Collection, String); public transient CommandLineOption option(String[]); static void <clinit>(); } org/gradle/cli/CommandLineParser$AfterOptions.class package org.gradle.cli; synchronized class CommandLineParser$AfterOptions extends CommandLineParser$ParserState { private final ParsedCommandLine commandLine; private void CommandLineParser$AfterOptions(ParsedCommandLine); public boolean maybeStartOption(String); public CommandLineParser$OptionParserState onStartOption(String, String); public CommandLineParser$ParserState onNonOption(String); } org/gradle/cli/CommandLineParser$OptionString.class package org.gradle.cli; synchronized class CommandLineParser$OptionString { private final String arg; private final String option; private void CommandLineParser$OptionString(String, String); public String getDisplayName(); public String toString(); } org/gradle/cli/AbstractPropertiesCommandLineConverter.class package org.gradle.cli; public abstract synchronized class AbstractPropertiesCommandLineConverter extends AbstractCommandLineConverter { public void AbstractPropertiesCommandLineConverter(); protected abstract String getPropertyOption(); protected abstract String getPropertyOptionDetailed(); protected abstract String getPropertyOptionDescription(); public void configure(CommandLineParser); public java.util.Map convert(ParsedCommandLine, java.util.Map) throws CommandLineArgumentException; } org/gradle/cli/ParsedCommandLineOption.class package org.gradle.cli; public synchronized class ParsedCommandLineOption { private final java.util.List values; public void ParsedCommandLineOption(); public String getValue(); public java.util.List getValues(); public void addArgument(String); public boolean hasValue(); } org/gradle/cli/CommandLineParser$OptionAwareParserState.class package org.gradle.cli; abstract synchronized class CommandLineParser$OptionAwareParserState extends CommandLineParser$ParserState { protected final ParsedCommandLine commandLine; protected void CommandLineParser$OptionAwareParserState(CommandLineParser, ParsedCommandLine); public boolean maybeStartOption(String); public CommandLineParser$ParserState onNonOption(String); } org/gradle/cli/CommandLineConverter.class package org.gradle.cli; public abstract interface CommandLineConverter { public abstract Object convert(Iterable, Object) throws CommandLineArgumentException; public abstract Object convert(ParsedCommandLine, Object) throws CommandLineArgumentException; public abstract void configure(CommandLineParser); } org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.class package org.gradle.cli; synchronized class CommandLineParser$BeforeFirstSubCommand extends CommandLineParser$OptionAwareParserState { private void CommandLineParser$BeforeFirstSubCommand(CommandLineParser, ParsedCommandLine); public CommandLineParser$OptionParserState onStartOption(String, String); } org/gradle/cli/SystemPropertiesCommandLineConverter.class package org.gradle.cli; public synchronized class SystemPropertiesCommandLineConverter extends AbstractPropertiesCommandLineConverter { public void SystemPropertiesCommandLineConverter(); protected String getPropertyOption(); protected String getPropertyOptionDetailed(); protected String getPropertyOptionDescription(); } org/gradle/cli/CommandLineParser$ParserState.class package org.gradle.cli; abstract synchronized class CommandLineParser$ParserState { private void CommandLineParser$ParserState(); public abstract boolean maybeStartOption(String); boolean isOption(String); public abstract CommandLineParser$OptionParserState onStartOption(String, String); public abstract CommandLineParser$ParserState onNonOption(String); public void onCommandLineEnd(); } org/gradle/cli/CommandLineParser$AfterFirstSubCommand.class package org.gradle.cli; synchronized class CommandLineParser$AfterFirstSubCommand extends CommandLineParser$OptionAwareParserState { private void CommandLineParser$AfterFirstSubCommand(CommandLineParser, ParsedCommandLine); public CommandLineParser$OptionParserState onStartOption(String, String); } gradle-cli-classpath.properties #module definition #Mon Dec 21 22:16:20 CET 2015 projects= runtime= Aula20180326/gradle/wrapper/gradle-wrapper.properties #Mon Mar 26 19:41:50 BRT 2018 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-all.zip Aula20180326/gradle.properties # Project-wide Gradle settings. # IDE (e.g. Android Studio) users: # Gradle settings configured through the IDE *will override* # any settings specified in this file. # For more details on how to configure your build environment visit # http://www.gradle.org/docs/current/userguide/build_environment.html # Specifies the JVM arguments used for the daemon process. # The setting is particularly useful for tweaking memory settings. org.gradle.jvmargs=-Xmx1536m # When configured, Gradle will run in incubating parallel mode. # This option should only be used with decoupled projects. More details, visit # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects # org.gradle.parallel=true Aula20180326/gradlew #!/usr/bin/env bash ############################################################################## ## ## Gradle start up script for UN*X ## ############################################################################## # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS="" APP_NAME="Gradle" APP_BASE_NAME=`basename "$0"` # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD="maximum" warn ( ) { echo "$*" } die ( ) { echo echo "$*" echo exit 1 } # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false case "`uname`" in CYGWIN* ) cygwin=true ;; Darwin* ) darwin=true ;; MINGW* ) msys=true ;; esac # Attempt to set APP_HOME # Resolve links: $0 may be a link PRG="$0" # Need this for relative symlinks. while [ -h "$PRG" ] ; do ls=`ls -ld "$PRG"` link=`expr "$ls" : '.*-> \(.*\)$'` if expr "$link" : '/.*' > /dev/null; then PRG="$link" else PRG=`dirname "$PRG"`"/$link" fi done SAVED="`pwd`" cd "`dirname \"$PRG\"`/" >/dev/null APP_HOME="`pwd -P`" cd "$SAVED" >/dev/null CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD="$JAVA_HOME/jre/sh/java" else JAVACMD="$JAVA_HOME/bin/java" fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else JAVACMD="java" which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi # Increase the maximum file descriptors if we can. if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then MAX_FD_LIMIT=`ulimit -H -n` if [ $? -eq 0 ] ; then if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then MAX_FD="$MAX_FD_LIMIT" fi ulimit -n $MAX_FD if [ $? -ne 0 ] ; then warn "Could not set maximum file descriptor limit: $MAX_FD" fi else warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" fi fi # For Darwin, add options to specify how the application appears in the dock if $darwin; then GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" fi # For Cygwin, switch paths to Windows format before running java if $cygwin ; then APP_HOME=`cygpath --path --mixed "$APP_HOME"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` JAVACMD=`cygpath --unix "$JAVACMD"` # We build the pattern for arguments to be converted via cygpath ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` SEP="" for dir in $ROOTDIRSRAW ; do ROOTDIRS="$ROOTDIRS$SEP$dir" SEP="|" done OURCYGPATTERN="(^($ROOTDIRS))" # Add a user-defined pattern to the cygpath arguments if [ "$GRADLE_CYGPATTERN" != "" ] ; then OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" fi # Now convert the arguments - kludge to limit ourselves to /bin/sh i=0 for arg in "$@" ; do CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` else eval `echo args$i`="\"$arg\"" fi i=$((i+1)) done case $i in (0) set -- ;; (1) set -- "$args0" ;; (2) set -- "$args0" "$args1" ;; (3) set -- "$args0" "$args1" "$args2" ;; (4) set -- "$args0" "$args1" "$args2" "$args3" ;; (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; esac fi # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules function splitJvmOpts() { JVM_OPTS=("$@") } eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" Aula20180326/gradlew.bat @if "%DEBUG%" == "" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @rem @rem ########################################################################## @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS= set DIRNAME=%~dp0 if "%DIRNAME%" == "" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if "%ERRORLEVEL%" == "0" goto init echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :findJavaFromJavaHome set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto init echo. echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :init @rem Get command-line arguments, handling Windowz variants if not "%OS%" == "Windows_NT" goto win9xME_args if "%@eval[2+2]" == "4" goto 4NT_args :win9xME_args @rem Slurp the command line arguments. set CMD_LINE_ARGS= set _SKIP=2 :win9xME_args_slurp if "x%~1" == "x" goto execute set CMD_LINE_ARGS=%* goto execute :4NT_args @rem Get arguments from the 4NT Shell from JP Software set CMD_LINE_ARGS=%$ :execute @rem Setup the command line set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar @rem Execute Gradle "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% :end @rem End local scope for the variables with windows NT shell if "%ERRORLEVEL%"=="0" goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 exit /b 1 :mainEnd if "%OS%"=="Windows_NT" endlocal :omega Aula20180326/settings.gradle include ':app'
Compartilhar