Aperçu
Fetch est une bibliothèque de gestion de téléchargement de fichiers simple, puissante et personnalisable pour Android.
Caractéristiques
API simple et facile à utiliser.
Téléchargement continu en arrière-plan.
Prise en charge du téléchargement simultané.
Possibilité de suspendre et de reprendre les téléchargements.
Définissez la priorité d'un téléchargement.
Prise en charge du téléchargement spécifique au réseau.
Possibilité de réessayer les téléchargements ayant échoué.
Possibilité de regrouper les téléchargements.
Suivi facile des progrès et du statut.
Téléchargez le rapport sur le temps restant (ETA).
Téléchargez les rapports de vitesse.
Enregistrez et récupérez les informations de téléchargement à tout moment.
Prise en charge des notifications.
Prise en charge du framework d'accès au stockage, du fournisseur de contenu et de l'URI.
Et plus encore...
Conditions préalables
Si vous enregistrez des téléchargements en dehors du bac à sable de votre application, vous devrez ajouter les autorisations de stockage suivantes au manifeste de votre application. Pour le SDK Android version 23(M) et supérieure, vous devrez également demander explicitement ces autorisations à l'utilisateur.
De plus, vous allez utiliser Internet pour télécharger des fichiers. Nous devons ajouter les autorisations d'accès à Internet dans le manifeste.
Comment utiliser Récupérer
Utiliser Fetch est simple ! Ajoutez simplement la dépendance Gradle au fichier build.gradle de votre application.
implémentation "com.tonyodev.fetch2:fetch2:3.0.12"
Utilisation d'Androidx :
implémentation "androidx.tonyodev.fetch2:xfetch2:3.1.6"
Ensuite, obtenez une instance de Fetch et demandez un téléchargement.
classe publique TestActivity extends AppCompatActivity { private Fetch fetch ; @Override protected void onCreate (@Nullable Bundle saveInstanceState) { super.onCreate(savedInstanceState); FetchConfiguration fetchConfiguration = new FetchConfiguration.Builder(this)
.setDownloadConcurrentLimit(3)
.construire(); fetch = Fetch.Impl.getInstance(fetchConfiguration); URL de chaîne = "http:www.example.com/test.txt" ; Fichier de chaîne = "/downloads/test.txt" ;
demande de demande finale = nouvelle demande (url, fichier); request.setPriority(Priority.HIGH); request.setNetworkType(NetworkType.ALL); request.addHeader("clientKey", "SD78DF93_3947&MVNGHE1WONG");
fetch.enqueue(request, updateRequest -> { //La demande a été mise en file d'attente avec succès pour le téléchargement.
}, error -> { //Une erreur s'est produite lors de la mise en file d'attente de la requête.
});
}
} Suivre la progression et l'état d'un téléchargement est très simple avec Fetch. Ajoutez simplement un FetchListener à votre instance Fetch, et l'auditeur sera averti chaque fois que l'état ou la progression d'un téléchargement change.
FetchListener fetchListener = new FetchListener() { @Override public void onQueued (@NotNull Télécharger le téléchargement, boolean waitOnNetwork) { if (request.getId() == download.getId()) { showDownloadInList(download);
}
} @Override public void onCompleted (@NotNull Télécharger le téléchargement) {
} @Override public void onError (@NotNull Télécharger le téléchargement) { Erreur error = download.getError();
} @Override public void onProgress (@NotNull Télécharger le téléchargement, long etaInMilliSeconds, long downloadBytesPerSecond) { if (request.getId() == download.getId()) { updateDownload(download, etaInMilliSeconds);
} int progress = download.getProgress();
} @Override public void onPaused (@NotNull Télécharger le téléchargement) {
} @Override public void onResumed (@NotNull Télécharger le téléchargement) {
} @Override public void onCancelled (@NotNull Télécharger le téléchargement) {
} @Override public void onRemoved (@NotNull Télécharger le téléchargement) {
} @Override public void onDeleted (@NotNull Télécharger le téléchargement) {
}
};fetch.addListener(fetchListener);//Supprimer l'écouteur une fois terminé.fetch.removeListener(fetchListener); Fetch prend en charge la pause et la reprise des téléchargements en utilisant l'identifiant de la demande. L'identifiant d'une requête est un identifiant unique qui mappe une requête à un téléchargement Fetch. Un téléchargement renvoyé par Fetch aura un identifiant qui correspond à l'identifiant de la demande qui a démarré le téléchargement.
Requête request1 = new Request(url, file);Request request2 = new Request(url2, file2);fetch.pause(request1.getId());
...fetch.resume(request2.getId());
Vous pouvez interroger Fetch pour obtenir des informations de téléchargement de plusieurs manières.
//Requête de tous les téléchargementsfetch.getDownloads(new Func>() { @Override public void call(List downloads) { //Accédez à tous les téléchargements ici
}
});//Obtenez tous les téléchargements avec un statusfetch.getDownloadsWithStatus(Status.DOWNLOADING, new Func>() { @Override public void call(List downloads) { //Accès aux téléchargements qui téléchargent
}
});// Vous pouvez également accéder aux téléchargements groupésint groupId = 52687447745;fetch.getDownloadsInGroup(groupId, new Func>() { @Override public void call(List downloads) { / /Accéder aux téléchargements groupés
}
});
Lorsque vous avez terminé avec une instance de Fetch, relâchez-la simplement.
//faire workfetch.close();//faire plus de travail
Téléchargeurs
Par défaut, Fetch utilise le client HttpUrlConnection via HttpUrlConnectionDownloader pour télécharger les requêtes. Ajoutez la dépendance Gradle suivante au build.gradle de votre application pour utiliser OkHttp Downloader à la place. Vous pouvez créer vos téléchargeurs personnalisés si nécessaire. Consultez la documentation Java pour plus de détails.
implémentation "com.tonyodev.fetch2okhttp:fetch2okhttp:3.0.12"
Utilisation d'Androidx :
implémentation "androidx.tonyodev.fetch2okhttp:xfetch2okhttp:3.1.6"
Configurez OkHttp Downloader pour Fetch à utiliser.
OkHttpClient okHttpClient = new OkHttpClient.Builder().build();FetchConfiguration fetchConfiguration = new FetchConfiguration.Builder(this)
.setDownloadConcurrentLimit(10)
.setHttpDownloader (nouveau OkHttpDownloader (okHttpClient))
.build();Fetch fetch = Fetch.Impl.getInstance(fetchConfiguration); RxFetch
Si vous souhaitez profiter des fonctionnalités de RxJava2 lors de l'utilisation de Fetch, ajoutez la dépendance gradle suivante au fichier build.gradle de votre application.
implémentation "com.tonyodev.fetch2rx:fetch2rx:3.0.12"
Utilisation d'Androidx :
implémentation "androidx.tonyodev.fetch2rx:xfetch2rx:3.1.6"
RxFetch facilite grandement la mise en file d'attente des demandes de téléchargement et les requêtes de téléchargement à l'aide des méthodes fonctionnelles rxJava2.
FetchConfiguration fetchConfiguration = new FetchConfiguration.Builder(this).build();Rxfetch rxFetch = RxFetch.Impl.getInstance(fetchConfiguration);rxFetch.getDownloads()
.asFlowable()
.subscribe(new Consumer>() { @Override public void accept(List downloads) throws Exception { //Accès aux résultats
}
}, new Consumer() { @Override public void accept(Throwable throwable) throws Exception { //Une erreur s'est produite final Error error = FetchErrorUtils.getErrorFromThrowable(throwable);
}
}); Récupérer le serveur de fichiers
Présentation de FetchFileServer. FetchFileServer est un serveur de fichiers TCP léger qui agit comme un serveur de fichiers HTTP spécialement conçu pour partager des fichiers entre appareils Android. Vous pouvez héberger des ressources de fichiers avec FetchFileServer sur un appareil et devoir récupérer les fichiers téléchargés à partir du serveur sur un autre appareil. Consultez l’exemple d’application pour plus d’informations. Le wiki sur FetchFileServer sera ajouté dans les prochains jours.
Commencez à utiliser FetchFileServer en ajoutant la dépendance gradle au fichier build.gradle de votre application.
implémentation "com.tonyodev.fetch2fileserver:fetch2fileserver:3.0.12"
Utilisation d'Androidx :
implémentation "androidx.tonyodev.fetch2fileserver:xfetch2fileserver:3.1.6"
Démarrez une instance FetchFileServer et ajoutez les fichiers de ressources qu'elle peut servir aux clients connectés.
classe publique TestActivity extends AppCompatActivity { FetchFileServer fetchFileServer ;
@Override protected void onCreate (@Nullable Bundle saveInstanceState) { super.onCreate(savedInstanceState); fetchFileServer = nouveau FetchFileServer.Builder (this)
.construire();
fetchFileServer.start(); //écouter les connexions client File file = new File("/downloads/testfile.txt"); FileResource fileResource = new FileResource(); fileResource.setFile(file.getAbsolutePath()); fileResource.setLength(file.length()); fileResource.setName("fichiertest.txt"); fileResource.setId(UUID.randomUUID().hashCode());
fetchFileServer.addFileResource(fileResource);
} @Override protected void onDestroy() { super.onDestroy(); fetchFileServer.shutDown(false);
}
} Télécharger un fichier à partir d’un FetchFileServer à l’aide de Fetch est simple.
classe publique TestActivity extends AppCompatActivity { Fetch fetch ; @Override protected void onCreate (@Nullable Bundle saveInstanceState) { super.onCreate(savedInstanceState); FetchConfiguration fetchConfiguration = new FetchConfiguration.Builder(this)
.setFileServerDownloader(new FetchFileServerDownloader()) //doit définir le téléchargeur du serveur de fichiers
.construire(); fetch = Fetch.Impl.getInstance(fetchConfiguration); fetch.addListener(fetchListener); Fichier de chaîne = "/downloads/sample.txt" ; URL de chaîne = new FetchFileServerUrlBuilder()
.setHostInetAddress("127.0.0.1", 6886) //adresse IP et port du serveur de fichiers
.setFileResourceIdentifier("testfile.txt") //nom ou identifiant de la ressource du fichier
.créer(); Demande de demande = nouvelle demande (url, fichier); fetch.enqueue(request, request1 -> { //Demande mise en file d'attente pour téléchargement
}, erreur -> { //Erreur lors de la mise en file d'attente du téléchargement
});
} @Override protected void onResume() { super.onResume(); fetch.addListener(fetchListener);
} @Override protected void onPause() { super.onPause(); fetch.removeListener(fetchListener);
} @Override protected void onDestroy() { super.onDestroy(); fetch.close();
} private FetchListener fetchListener = new AbstractFetchListener() { @Override public void onProgress (@NotNull Télécharger le téléchargement, long etaInMilliSeconds, long downloadBytesPerSecond) { super.onProgress(download, etaInMilliSeconds, downloadBytesPerSecond); Log.d("TestActivity", "Progress: " + download.getProgress());
} @Override public void onError (@NotNull Télécharger le téléchargement) { super.onError (télécharger); Log.d("TestActivity", "Erreur : " + download.getError().toString());
} @Override public void onCompleted (@NotNull Download download) { super.onCompleted (download); Log.d("TestActivité", "Terminé ");
}
} ;
} Récupérer1 Migration
Migrez les téléchargements de Fetch1 vers Fetch2 à l'aide de l'assistant de migration. Ajoutez la dépendance gradle suivante au fichier build.gradle de votre application.
implémentation "com.tonyodev.fetchmigrator:fetchmigrator:3.0.12"
Utilisation d'Androidx :
implémentation "androidx.tonyodev.fetchmigrator:xfetchmigrator:3.1.6"
Ensuite, lancez le Migrator.
if (!didMigrationRun()) { //La migration doit s'exécuter sur un thread d'arrière-plan new Thread(new Runnable() { @Override public void run() { try { final List transféréDownloads = FetchMigrator.migrateFromV1toV2(getApplicationContext() , APP_FETCH_NAMESPACE); //TODO : mettre à jour les références externes des identifiants pour (DownloadTransferPair transféréDownload : transféréDownloads) { Log.d("newDownload", transféréDownload.getNewDownload().toString()); Log.d("oldId dans Fetch v1", transféréDownload.getOldID() + "");
} FetchMigrator.deleteFetchV1Database(getApplicationContext()); setMigrationDidRun(true); //Configurer et exécuter Fetch2 après la migration
} catch (SQLException e) { e.printStackTrace();
}
}
}).commencer();
} else { //Configurer et exécuter Fetch2 normalement
} Contribuer
La récupération ne peut s'améliorer que si vous apportez des contributions au code. Vous avez trouvé un bug ? Signalez-le. Vous avez une idée de fonctionnalité que vous aimeriez voir dans Fetch ? Contribuez au projet !
Licence
Copyright (C) 2017 Tonyo Francis.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
