Tenho poucas perguntas sobre o uso do Volley em meus projetos:

1. Essa biblioteca pode ser usada em qualquer projeto Java ou apenas no Android?
2. Eu vejo várias ramificações aqui e nenhuma documentação sobre qual ramificação deve começar. Com que ramo devo começar?
3. Como você integra esta biblioteca em seu próprio projeto? Qual é a melhor abordagem: faça do Volley um projeto de biblioteca independente e gire um jarro e coloque-o no seu projeto ou copie todo o código-fonte dentro do seu projeto?

$ git clone https://android.googlesource.com/platform/frameworks/volley
$ cd volley
$ android update project -p .
$ ant jar

Em seguida, copie bin/volley.jarpara sua libs/pasta e pronto!

fonte

Na lição Volley , o Google instrui como adicionar o Volley ao nosso projeto como um projeto da Biblioteca Android ou como um.jar arquivo.

Veja como criar o .jararquivo Volley usando o Android Studio ou Eclipse :

NOTA:

Nos dois casos, sugiro renomear o .jararquivo para a data do último commit do Volley, ou seja volley_20150319.jar, para manter a versão simples.

Android Studio:

1. Clone o repositório Volley via Git.
2. Importe o projeto para o Android Studio. (Normalmente, seleciono o arquivo de classificação do projeto ao importar no Android Studio)
3. Crie o projeto. (Eu tive que alterar as configurações de compilação gradle para refletir as ferramentas de compilação e a versão mais recentes, mas geralmente está atualizado).
4. No seu explorador de arquivos, navegue até [your local path to volley]/build/intermediate/bundles/
5. Nas pastas debuge releasevocê encontrará um arquivo JAR chamadoclasses.jar .
6. Copie qualquer arquivo JAR para sua libs/pasta.
7. Gradle sync, e pronto.

Eclipse:

1. Clone o repositório Volley via Git.
2. Importe o projeto para o eclipse.
3. Clique com o botão direito do mouse no projeto e selecione Exportar ...
4. Selecione o arquivo Java / JAR .
5. Estamos interessados ​​apenas na pasta src e nada mais. A maneira mais fácil de garantir que apenas ele esteja selecionado é desmarcar o projeto e selecionar o src pasta dentro.
6. Verifique os recursos e arquivos de classe gerados pela exportação .
7. OPCIONAL: Se você desejar que o Javadoc fique visível, selecione também os recursos Exportar arquivos de origem Java .
8. Crie o arquivo JAR e coloque-o na sua libs/pasta.

1) Esta biblioteca também pode ser usada como biblioteca de rede em projetos Java normais OU OU é estritamente apenas para Android

É apenas para Android, pois depende de classes específicas do Android. Você pode dizer isso olhando para o código fonte, para coisas assimRequestQueue .

2) Eu vejo várias ramificações aqui e nenhuma documentação em qual ramificação deve começar. Com que ramo devo começar?

As instruções da apresentação do Google I | O eram apenas clonar o gitrepositório, que seria retirado da masterramificação por padrão.

3) Como integrar esta biblioteca em seu próprio projeto? Que abordagem é melhor: Crie o Volley como um projeto de biblioteca independente e gire um jarro e coloque-o no seu projeto ou Copie todo o código-fonte dentro do seu projeto?

As instruções da apresentação do Google I | O foram adicionar o código-fonte ao seu projeto. Pessoalmente, acho que essa é uma abordagem bizarra.

você pode baixar o volley.jar

Fonte: AndroidHive

copie Volley.jarpara libs

Então

Clique com o botão direito em volley.jar ->Adicionar como biblioteca

A biblioteca Volley agora é publicada pelo Android Open Source Project:

dependencies {
    implementation 'com.android.volley:volley:1.1.0'
}

ATUALIZAÇÃO: O Volley agora é oficial e está disponível no JCenter. Veja como importá-lo:

compile 'com.android.volley:volley:1.0.0'

MANEIRA DEPRESTADA:

Se você estiver usando Gradle, poderá importar o Volley daqui .

dependencies {
    compile 'com.mcxiaoke.volley:library:1.0.+'
}

Nota

Este é um espelho não oficial (com algumas correções menores, consulte o Changelog para obter detalhes.) Para a biblioteca de vôlei do Android , o código fonte será sincronizado periodicamente com o repositório oficial de vôlei.

Muitas maneiras

Como existem muitas respostas sobre uma única abordagem, mas nenhuma que está comparando as diferentes maneiras de jogar vôlei, também coloco meus dois centavos. Sinta-se à vontade para editar / aprimorar essa resposta também.

Adicione-o como biblioteca - (solução rápida)

1. Faça o download em: androidhive
2. Coloque-o na sua [MyProjectPath]/app/libs/pasta
3. No Android Studio right-click, selecione eAdd As Library...

Arquivos de origem do git - (uma solução bastante oficial)

1. Faça o download / instale o cliente git (se você ainda não o tiver no sistema) (consulte outra viagit clone https://github.com/git/git ... sry bad one, mas não resistiu ^^)
2. Executar git clone https://android.googlesource.com/platform/frameworks/volley

3. Copie a compasta de dentro [path_where_you_typed_git_clone]/volley/srcpara a app/src/main/javapasta de projetos (ou integre-a, se você já tiver uma pasta com !!) ;-))

   Os arquivos aparecem imediatamente no Android Studio. Para o Eclipse, você terá que entrar right-clickna srcpasta e pressionar refresh(ou F5) primeiro.

   Fazê-lo via git é o que é oficialmente sugerido nos tutoriais do Android ( veja aqui ).

Gradle através de um espelho "não oficial" - (solução dinâmica)

1. No src/build.gradlearquivo do seu projeto, adicione a seguinte dependência de vôlei:

       dependencies {
           compile fileTree(dir: 'libs', include: ['*.jar'])
           // ...
   
           compile 'com.mcxiaoke.volley:library:1.+'
       }

2. Clique no Try Againque deve aparecer imediatamente na parte superior do arquivo ou apenas Buildse não estiver

   A principal "vantagem" aqui é que isso manterá a versão atualizada para você, enquanto nos outros dois casos você teria que atualizar manualmente o vôlei.

   No lado negativo, não é oficialmente do Google, mas um espelho semanal de terceiros.

   Mas esses dois pontos são realmente relativos ao que você precisa / deseja. Além disso, se você não quiser atualizações, basta colocar a versão desejada lá, por exemplo compile 'com.mcxiaoke.volley:library:1.0.7'.

Se você usa o GIT para seu próprio gerenciamento de código, por que não simplesmente adicioná-lo como um submódulo para projetar ...

git submodule add https://android.googlesource.com/platform/frameworks/volley -b master Volley

Dessa forma, conforme a base de código do Volley é atualizada, é fácil atualizar ...

git submodule git pull

Você pode estender a classe principal do Volley em seu próprio projeto para modificação, o que impede que você tenha que mexer na codificação de suas alterações toda vez que a estrutura do Volley for atualizada.

Aqui está um pequeno Início Rápido para uma Solicitação de Volley Http. É extremamente fácil de integrar.

• Você precisa de um Volley RequestQueue amplo para aplicativos:

  1. private static RequestQueue reqQueue;

Você pode colocá-lo em sua classe Application e disponibilizá-lo estaticamente via getRequestQueue ().

• Então você já pode usar o método RequestQueue.add () para executar a primeira solicitação com o Volley.

  2. reqQueue.add(...)

• Use JsonObjectRequest para consultar um único objeto, use JsonArrayRequest para consultar uma lista de objetos.

  queue.add(new JsonArrayRequest(URL, new Listener<JSONArray>() {
  
      @Override
      public void onResponse(JSONArray response) {
          //SUCCESS
      }}, new ErrorListener() {
  
      @Override
      public void onErrorResponse(VolleyError error) {
          //ERROR
      }}));

• Lembre-se de definir o cabeçalho Http Expires corretamente no servidor, para que o Volley possa fazer uso de seu recurso de cache integrado

Aqui está outra maneira com o Android Studio e Gradle:

Você precisa do próximo em seu build.gradle do seu projeto (no nível da estrutura do aplicativo):

repositories {
    maven {
        url 'https://github.com/Goddchen/mvn-repo/raw/master/'
    }
    mavenCentral()
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    // You must install or update the Support Repository through the SDK manager to use this dependency.
    compile 'com.android.support:support-v4:20.+'
    compile 'com.android:volley:1.+'
}

Primeiro clone o projeto do Git

$git clone https://android.googlesource.com/platform/frameworks/volley

• vôlei de importação no eclipse.
• Clique com o botão direito do mouse em seu projeto-> Propriedade-> android
• Adicionar biblioteca-> escolher vôlei (se você não vê vôlei lá, clique direito na biblioteca de vôlei, vá para propriedade e android e clique em biblioteca)
• Depois de adicionar o vôlei como biblioteca, você poderá começar a usá-lo no seu aplicativo.

Alguma classe básica de vôlei que você deve saber é

• RequestQueue
• JsonArrayRequest
• JsonObjectRequest

Para usar o vôlei primeiro, você precisa criar o objeto RequestQueue

RequestQueue mQueue = Volley.newRequestQueue(getApplicationContext());

Segundo -> faça uma solicitação usando JsonArrayRequest ou JsonObjectRequest

JsonArrayRequest mJsonRequest = new JsonArrayRequest(url, 
            new Listener<JSONArray>() {

                @Override
                public void onResponse(JSONArray response) {
                    // here you can parse response and use accordingly
                }
            }, new ErrorListener() {

                @Override
                public void onErrorResponse(VolleyError error) {
                    // here you will receive errors and show proper message according to error type

                }
            });

e, finalmente, colocar o pedido na fila. ie

mQueue.add(mJsonRequest);

Também sugiro que você faça um Singleton de RequestQuery.

Adicionar um jar do Volley (ou qualquer jar) ao Android Studio 1.0.2 agora é consideravelmente mais fácil. Fora do Android Studio, copie volley.jarpara <yourproject>/app/libs(que já deveria existir). Como a configuração padrão do Gradle inclui esta linha:

 compile fileTree(dir: 'libs', include: ['*.jar'])

... tudo está configurado agora. Pode não parecer assim, porque a visualização padrão da Estrutura do projeto (File -> Project Structure)não mostra o libsdiretório. Para vê-lo, você precisa usar o botão giratório logo acima da visualização Estrutura do Projeto para mudar Androidpara Project.

Você pode ver que ele está funcionando criando o aplicativo (pode não ser necessário) e, em seguida, começando a digitar algum código como este:

 RequestQueue request

Você verá que o Android Studio solicita a conclusão RequestQueue (com.android.volley).

Também é muito fácil criar um aar de depuração, se essa for a sua preferência.

git clone https://android.googlesource.com/platform/frameworks/volley

Em seguida, crie um novo projeto de estúdio do Android (apenas um projeto de aplicativo comum) em um diretório diferente. Quando terminar, adicione um novo submódulo (Arquivo | Novo Módulo). Escolha a opção importar projeto existente e aponte-a para o diretório em que efetuou o check-out do vôlei. Feito isso, você pode criar seu módulo e ele criará um arquivo aar.

Usando o eclipse Luna, você deve:

• clone-o do GIT.
• corte (copie e exclua) a pasta COM na pasta JAVA abaixo da pasta SRC, como no projeto normal do Android.
• altere o destino project.properties para 15 em vez de 8.
• construir o projeto.
• exporte o projeto como arquivo jar, incluindo a fonte - use a ferramenta de exportação.
• mantenha no jar exportado apenas as pastas COM e META-INF, exclua todas as outras pastas - use a ferramenta zip para excluir o conteúdo do jar.
• use este jar como seu projeto de jarro de vôlei.
• Coloque o jar Volley na pasta lib do seu projeto Android de destino.

Se você estiver usando o Android Studio, coloque essa linha no arquivo gradle

compile 'com.mcxiaoke.volley:library:1.0.15'

Se você deseja usar o método GET, deve ter algo parecido.

private void weatherData() {
    JsonObjectRequest jsonObjReq = new JsonObjectRequest(
        Request.Method.GET,
        "URL with JSON data",
        new Response.Listener<JSONObject>() {
             @Override
             public void onResponse(JSONObject response) {
                 try {
                      //Your code goes here      
                 } catch (JSONException e) {
                      Log.e("TAG", e.toString());
                 }
             }
        }, 
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
            }
        });
    // Adding request to request queue
    AppController.getInstance().addToRequestQueue(jsonObjReq);
}

Mas se você deseja postar dados no servidor, construa uma biblioteca HashMap e Volley e converta esses valores de chave / par em objetos JSON antes de publicá-los no servidor. Aqui está um exemplo.

final HashMap<String, String> postParams = new HashMap<String, String>();
postParams.put("username", username);
postParams.put("password", password);

Response.Listener<JSONObject> listener;
Response.ErrorListener errorListener;
final JSONObject jsonObject = new JSONObject(postParams);

JsonObjectRequest jsonObjReq = new JsonObjectRequest(
    "YOUR URL WITH JSON DATA", 
    jsonObject,
    new com.android.volley.Response.Listener<JSONObject>() {
        @Override
        public void onResponse(JSONObject response) {
            Log.d("TAG", response.toString());
            try {
                if (response.getString("status").equals("fail")) {

                } else if (response.getString("status").equals("success")) {

                } catch (JSONException e) {
                     Log.e("TAG", e.toString())
                }
            }
        }, 
        new com.android.volley.Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
             //VolleyLog.d("TAG", "Error: " + error.getMessage());
            //pDialog.dismiss();

        }
    }) {
        @Override
        public String getBodyContentType() {
            return "application/json; charset=utf-8";
        }
    };
    // Adding request to request queue
    AppController.getInstance().addToRequestQueue(jsonObjReq, tag_json_obj);

    VolleySingleton.getInstance(getApplicationContext()).
    addToRequestQueue(jsonObjRequest);
 }

Clonei o projeto Volley e adicionei arquivos de configuração que permitem a construção da biblioteca com o Gradle.

• Clone pronto para Gradle do Google Android Volley

Com isso, você pode instalar a biblioteca em seu repositório local do Maven e referenciá-la a partir de um projeto Android via Gradle.

Exigências

1. Maven
2. Gradle

Como usar

1. Clone meu repositório
2. Construa e instale a biblioteca Volley
3. Referenciar a biblioteca em um projeto Android

Correções de bugs

Lembre-se de que existem vários clones por aí que têm melhorias para a biblioteca . Pode ser necessário integrá-los e compilar sua versão aprimorada privada da biblioteca.

Benefícios

Além da própria biblioteca, o script de construção gera JavaDoc e arquivos de origem .

Eu enfrentei um problema quando a biblioteca de suporte foi listada na segunda linha. Reordenar essas duas declarações funcionou para mim.

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.mcxiaoke.volley:library:1.0.6'
    compile 'com.android.support:support-v4:20.+'
}

O Volley pode ser adicionado como um submódulo git no seu repositório de projetos atual. Este submódulo git apontará para o repositório oficial git do Volley. Portanto, você pode obter atualizações do repositório oficial do git apenas atualizando o ponteiro do submódulo.

Além disso, se você adicionar o Volley como um Módulo de Biblioteca em seu projeto principal, poderá personalizá-lo facilmente. Também será muito útil para fins de depuração.

Para conseguir isso, siga as etapas abaixo:

Etapa I:

Adicione voleio como submódulo no projeto de aplicativo Android GIT Repo. submódulo git add -b master https://android.googlesource.com/platform/frameworks/volley Libraries / Volley

Etapa II:

Em settings.gradle, adicione o seguinte para adicionar voleio como um módulo de projeto de estúdio. incluir projeto ': Volley' (': Volley'). projectDir = new File ('../ Libraries / Volley')

Etapa III:

Em app / build.gradle, adicione a seguinte linha para compilar o projeto de compilação do Volley (': Volley')

Isso seria tudo! Volley foi adicionado com sucesso no projeto.

Sempre que quiser obter o código mais recente do repositório oficial do Google Volley, basta executar o comando abaixo

git submodule foreach git pull

Para informações mais detalhadas: https://gitsubmoduleasandroidtudiomodule.blogspot.in/

Código de exemplo do GIT Repo: https://github.com/arpitratan/AndroidGitSubmoduleAsModule

Para futuros leitores

Adoro trabalhar com o Volley . Para economizar tempo de desenvolvimento, tentei escrever uma pequena biblioteca útil Gloxey Netwok Manager para configurar o Volley com o meu projeto. Inclui analisador JSON e diferentes outros métodos que ajudam a verificar a disponibilidade da rede.

A Library fornece ConnectionManager.classquais métodos diferentes para solicitações de Volley String e Volley JSON estão disponíveis. Você pode fazer pedidos de GET, PUT, POST, DELETE com ou sem cabeçalho. Você pode ler a documentação completa aqui .

Basta colocar esta linha no seu arquivo gradle.

dependências {

   compile 'io.gloxey.gnm:network-manager:1.0.1'

}