web-dev-qa-db-fra.com

Comment utiliser opencv en utilisant Gradle?

Je souhaite utiliser Android Studio pour développer une application à l'aide de l'outil de génération Gradle. Je ne peux pas insérer le référentiel OpenCV ni la bibliothèque sur build.gradle. Ma .gradle fichier est comme ci-dessous:

buildscript {
    repositories {
        mavenCentral()

    }
    dependencies {
        classpath 'com.Android.tools.build:gradle:0.5.+'
    }
}
apply plugin: 'Android'

repositories {
    mavenCentral()
}

dependencies {
    compile 'com.Android.support:support-v4:13.0.+'
}

Android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 7
        targetSdkVersion 16
    }
}

Comment puis-je ajouter OpenCV à mon projet?

androidopencvgradleandroid-gradle
59
Omer Sonmez
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.Android.tools.build:gradle:0.5.+'
    }
}
apply plugin: 'Android'

repositories {
    mavenCentral()
    maven {
        url 'http://maven2.javacv.googlecode.com/git/'
    }
}

dependencies {
    compile 'com.Android.support:support-v4:13.0.+'
    compile 'com.googlecode.javacv:javacv:0.5'
    instrumentTestCompile 'junit:junit:4.4'
}

Android {
    compileSdkVersion 14
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 7
        targetSdkVersion 14
    }
}

Cela a fonctionné pour moi :)

7
Omer Sonmez

Vous pouvez le faire très facilement dans Android Studio.

Suivez les étapes ci-dessous pour ajouter Open CV à votre projet en tant que bibliothèque.

  1. Créez un dossier libraries sous le répertoire principal de votre projet. Par exemple, si votre projet est OpenCVExamples, vous créerez un dossier OpenCVExamples/libraries.

  2. Allez à l’emplacement où vous avez le SDK "\ OpenCV-2.4.8-Android-sdk\sdk" où vous trouverez le dossier Java, renommez-le opencv.

  3. Maintenant, copiez le répertoire opencv complet du SDK dans le dossier des bibliothèques que vous venez de créer.

  4. Maintenant, créez un fichier build.gradle Dans le répertoire opencv avec le contenu suivant

    apply plugin: 'Android-library'

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.Android.tools.build:gradle:0.9.+'
    }
}

Android {
    compileSdkVersion 19
    buildToolsVersion "19.0.1"

    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 19
        versionCode 2480
        versionName "2.4.8"
    }

    sourceSets {
        main {
            manifest.srcFile 'AndroidManifest.xml'
            Java.srcDirs = ['src']
            resources.srcDirs = ['src']
            res.srcDirs = ['res']
            aidl.srcDirs = ['src']
        }
    }
}

  5. Editez votre fichier settings.gradle dans le répertoire principal de votre application et ajoutez cette ligne:

    include ':libraries:opencv'

  6. Synchronisez votre projet avec Gradle et il devrait ressembler à ceci

    screen 1

  7. Cliquez avec le bouton droit de la souris sur votre projet, puis sur Open Module Settings, Puis sur Choisir les modules dans la liste de gauche, cliquez sur le module de votre application, cliquez sur l'onglet Dépendances, puis sur le bouton + pour ajouter une nouvelle dépendance de module.

    enter image description here

  8. Choisissez Module dependency. Il ouvrira une boîte de dialogue avec une liste de modules à choisir; sélectionnez “: libraries: opencv”.

    enter image description here

  9. Créez un dossier jniLibs à l’emplacement /app/src/main/ Et copiez tout le dossier avec les fichiers * .so (armeabi, armeabi-v7a, mips, x86) dans le jniLibs du OpenCV SDK.

    enter image description here

  10. Cliquez sur OK. Maintenant que tout est fait, profitez-en avec OpenCV.

129
Ajay S

Selon la documentation OpenCV ( 1 ), les étapes ci-dessous utilisant Gestionnaire OpenCV est la méthode recommandée pour utiliser OpenCV pour la production s'exécute. Mais OpenCV Manager ( 2 ) est une installation supplémentaire de Google Play Store. Donc, si vous préférez un apk autonome (n'utilisant pas OpenCV Manager) ou étant actuellement en phase développement/test, je vous suggère de répondre en https://stackoverflow.com/a/27421494/1180117 .

Procédure recommandée pour utiliser OpenCV dans Android Studio avec OpenCV Manager.

  1. Décompressez OpenCV Android sdk téléchargé depuis OpenCV.org ()
  2. À partir de File -> Import Module, Choisissez le dossier sdk/Java Dans l’archive opencv non compressée.
  3. Mettez à jour build.gradle Sous le module OpenCV importé pour mettre à jour 4 champs afin qu'ils correspondent au build.gradle De votre projet a) compileSdkVersion b) buildToolsVersion c) minSdkVersion et 4) targetSdkVersion.
  4. Ajoutez une dépendance de module par Application -> Module Settings, Puis sélectionnez l'onglet Dependencies. Cliquez sur l'icône + En bas (ou à droite), choisissez Module Dependency Et sélectionnez le module OpenCV importé.

Enfin, dans votre classe d’activité, ajoutez un extrait de code ci-dessous.

    public class SampleJava extends Activity  {

        private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
        @Override
        public void onManagerConnected(int status) {
            switch(status) {
                case LoaderCallbackInterface.SUCCESS:
                    Log.i(TAG,"OpenCV Manager Connected");
                    //from now onwards, you can use OpenCV API
                    Mat m = new Mat(5, 10, CvType.CV_8UC1, new Scalar(0));
                    break;
                case LoaderCallbackInterface.INIT_FAILED:
                    Log.i(TAG,"Init Failed");
                    break;
                case LoaderCallbackInterface.INSTALL_CANCELED:
                    Log.i(TAG,"Install Cancelled");
                    break;
                case LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION:
                    Log.i(TAG,"Incompatible Version");
                    break;
                case LoaderCallbackInterface.MARKET_ERROR:
                    Log.i(TAG,"Market Error");
                    break;
                default:
                    Log.i(TAG,"OpenCV Manager Install");
                    super.onManagerConnected(status);
                    break;
            }
        }
    };

    @Override
    protected void onResume() {
        super.onResume();
        //initialize OpenCV manager
        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_9, this, mLoaderCallback);
    }
}

Remarque: Vous ne pouvez passer d’appels OpenCV qu’après avoir reçu le rappel réussi sur la méthode onManagerConnected. Au cours de l'exécution, vous serez invité à installer OpenCV Manager à partir de Play Store, s'il n'est pas déjà installé. Pendant le développement, si vous n'avez pas accès à Play Store ou utilisez emualtor, utilisez le gestionnaire Apk OpenCV approprié présent dans le dossier apk sous l'archive OpenCV sdk téléchargée.

Pros

  • Réduction de la taille de l’APK d’environ 40 Mo (envisagez également les mises à niveau).
  • OpenCV Manager installe des fichiers binaires optimisés pour votre matériel, ce qui pourrait accélérer les choses.
  • Les mises à niveau vers OpenCV Manager peuvent enregistrer votre application contre les bogues dans OpenCV.
  • Différentes applications peuvent partager la même bibliothèque OpenCV.

Inconvénients

  • Expérience de l'utilisateur final - peut ne pas aimer l'installation. Invite avec votre application.
25
Kiran

L'intégration d'OpenCV étant un tel effort, nous l'avons pré-packagée et publiée via JCenter ici: https://github.com/quickbirdstudios/opencv-Android

Incluez simplement ceci dans la section des dépendances build.gradle de votre module

dependencies {
  implementation 'com.quickbirdstudios:opencv:3.4.1'
}

et cela dans la section des dépôts build.gradle de votre projet

repositories {
  jcenter()
}

Vous n'obtiendrez pas d'erreur de peluches après l'importation gradle, mais n'oubliez pas d'initialiser la bibliothèque OpenCV comme ceci dans MainActivity

public class MainActivity extends Activity {
    static {
        if (!OpenCVLoader.initDebug())
            Log.d("ERROR", "Unable to load OpenCV");
        else
            Log.d("SUCCESS", "OpenCV loaded");
    }
...
...
...
...
9
Malte

Si vous ne voulez pas utiliser JavaCV, cela fonctionne pour moi ...

Étape 1- Téléchargez les ressources

Téléchargez OpenCV Android SDK à partir de http://opencv.org/downloads.html

Étape 2 - Copier les fichiers binaires OpenCV dans votre APK

Copiez libopencv_info.so & libopencv_Java.so à partir de

OpenCV-2.?.?-Android-sdk -> sdk -> native -> libs -> armeabi-v7a

à

Project Root -> Your Project -> lib - > armeabi-v7a

Compressez le dossier lib et renommez-le en un fichier quelconque-v7a.jar.

Copiez ce fichier .jar et placez-le ici dans votre projet

Project Root -> Your Project -> libs

Ajoutez cette ligne à vos projets build.gradle dans la section des dépendances

compile files('libs/whatever-v7a.jar')

Lorsque vous compilerez maintenant, vous verrez probablement que votre .apk est environ 4 Mo plus gros.

(Répétez l'opération pour "armeabi" si vous souhaitez également prendre en charge ARMv6, qui n'est probablement plus nécessaire.)

Étape 3 - Ajout du Java sdk à votre projet

Copiez le dossier Java d'ici

OpenCV-2.?.?-Android-sdk -> sdk

à

Project Root -> Your Project -> libs (Même endroit que votre fichier .jar);

(Vous pouvez renommer le nom du dossier "Java" en "OpenCV")

Dans ce dossier récemment copié, ajoutez un fichier build.gradle typique; J'ai utilisé ceci:

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.Android.tools.build:gradle:0.6.+'
    }
}

apply plugin: 'Android-library'

repositories {
    mavenCentral();
}

Android {
    compileSdkVersion 19
    buildToolsVersion "19"

    defaultConfig {
        minSdkVersion 15
        targetSdkVersion 19
    }

    sourceSets {
        main {
            manifest.srcFile 'AndroidManifest.xml'
            Java.srcDirs = ['src']
            resources.srcDirs = ['src']
            aidl.srcDirs = ['src']
            renderscript.srcDirs = ['src']
            res.srcDirs = ['res']
            assets.srcDirs = ['assets']
        }
    }
}

Dans votre fichier settings.gradle de la racine du projet, changez-le également:

include ':Project Name:libs:OpenCV', ':Project Name'

Dans la racine de votre projet -> Nom du projet -> Le fichier build.gradle de la section des dépendances, ajoutez cette ligne:

compile project(':Project Name:libs:OpenCV')

Étape 4 - Utiliser OpenCV dans votre projet

Reconstruisez et vous devriez pouvoir importer et commencer à utiliser OpenCV dans votre projet.

import org.opencv.Android.OpenCVLoader;
...
if (!OpenCVLoader.initDebug()) {}

Je sais que si un peu de bidouille, mais je pensais que je le posterais de toute façon.

9
Paito

J'ai posté un nouveau message sur la façon de construire un Android application NDK avec OpenCV inclus en utilisant Android Studio et Gradle. Plus d'informations sont visibles ici , j'ai résumé deux méthodes:

(1) lancer ndk-build dans la tâche Gradle

sourceSets.main.jni.srcDirs = []

task ndkBuild(type: Exec, description: 'Compile JNI source via NDK') {
    ndkDir = project.plugins.findPlugin('com.Android.application').getNdkFolder()
    commandLine "$ndkDir/ndk-build",
            'NDK_PROJECT_PATH=build/intermediates/ndk',
            'NDK_LIBS_OUT=src/main/jniLibs',
            'APP_BUILD_SCRIPT=src/main/jni/Android.mk',
            'NDK_APPLICATION_MK=src/main/jni/Application.mk'
}

tasks.withType(JavaCompile) {
    compileTask -> compileTask.dependsOn ndkBuild
}

(2) lancer ndk-build avec un outil externe

Paramètres: NDK_PROJECT_PATH=$ModuleFileDir$/build/intermediates/ndk NDK_LIBS_OUT=$ModuleFileDir$/src/main/jniLibs NDK_APPLICATION_MK=$ModuleFileDir$/src/main/jni/Application.mk APP_BUILD_SCRIPT=$ModuleFileDir$/src/main/jni/Android.mk V=1

Plus d'informations peuvent être vues ici

7
javayhu

Cela fonctionne avec Android Studio 1.2 + OpenCV-2.4.11-Android-sdk (.Zip) également.

Il suffit de faire ce qui suit:

1) Suivez la réponse qui commence par "Vous pouvez le faire très facilement dans Android Studio. Suivez les étapes ci-dessous pour ajouter OpenCV à votre projet en tant que bibliothèque." Par TGMCians.

2) Modifier dans le <yourAppDir>\libraries\opencv dossier votre nouvellement créé build.gradle to (étape 4 de la réponse des TGMCians, adapté à OpenCV2.4.11-Android-sdk et utilisant gradle 1.1.0 =):

apply plugin: 'Android-library'

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.Android.tools.build:gradle:1.1.0'
    }
}

Android {
    compileSdkVersion 21
    buildToolsVersion "21.1.2"

    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 21
        versionCode 2411
        versionName "2.4.11"
    }

    sourceSets {
        main {
            manifest.srcFile 'AndroidManifest.xml'
            Java.srcDirs = ['src']
            resources.srcDirs = ['src']
            res.srcDirs = ['res']
            aidl.srcDirs = ['src']
        }
    }
}

3) Les fichiers * .so situés dans les répertoires "armeabi", "armeabi-v7a", "mips", "x86" peut être trouvé sous (emplacement OpenCV par défaut): ..\OpenCV-2.4.11-Android-sdk\OpenCV-Android-sdk\sdk\native\libs _ (étape 9 de la réponse des TGMCians).

Profitez-en et si cela vous aide, donnez-nous une réputation positive. J'ai besoin de 50 pour répondre directement aux réponses (19 restantes) :)

5
Rob

Voici les étapes nécessaires pour utiliser OpenCV avec Android Studio 1.2:

  • Téléchargez OpenCV et extrayez l'archive
  • Ouvrez votre projet d’application dans Android Studio
  • Allez dans Fichier -> Nouveau -> Module d'importation ...
  • Sélectionnez sdk/Java Dans le répertoire que vous avez extrait avant
  • Définissez le nom du module sur opencv
  • Appuyez sur Suivant puis sur Terminer
  • Ouvrez le fichier build.gradle sous le module OpenCV importé et mettez à jour compileSdkVersion et buildToolsVersion vers les versions de votre ordinateur.

  • Ajouter compile project(':opencv') à votre application build.gradle

    dependencies {
    ...
    compile project(':opencv')
}

  • Appuyez sur Synchroniser le projet avec des fichiers Gradle

3
Mattia Maestrini

OpenCV Android Le SDK contient un exemple de fichier gradle.build avec des commentaires utiles: https://github.com/opencv/opencv/blob/master/modules/Java/Android_sdk/ build.gradle.in

//
// Notes about integration OpenCV into existed Android Studio application project are below (application 'app' module should exist).
//
// This file is located in <OpenCV-Android-sdk>/sdk directory (near 'etc', 'Java', 'native' subdirectories)
//
// Add module into Android Studio application project:
//
// - Android Studio way:
//   (will copy almost all OpenCV Android SDK into your project, ~200Mb)
//
//   Import module: Menu -> "File" -> "New" -> "Module" -> "Import Gradle project":
//   Source directory: select this "sdk" directory
//   Module name: ":opencv"
//
// - or attach library module from OpenCV Android SDK
//   (without copying into application project directory, allow to share the same module between projects)
//
//   Edit "settings.gradle" and add these lines:
//
//   def opencvsdk='<path_to_opencv_Android_sdk_rootdir>'
//   // You can put declaration above into gradle.properties file instead (including file in HOME directory),
//   // but without 'def' and apostrophe symbols ('): opencvsdk=<path_to_opencv_Android_sdk_rootdir>
//   include ':opencv'
//   project(':opencv').projectDir = new File(opencvsdk + '/sdk')
//
//
//
// Add dependency into application module:
//
// - Android Studio way:
//   "Open Module Settings" (F4) -> "Dependencies" tab
//
// - or add "project(':opencv')" dependency into app/build.gradle:
//
//   dependencies {
//       implementation fileTree(dir: 'libs', include: ['*.jar'])
//       ...
//       implementation project(':opencv')
//   }
//
//
//
// Load OpenCV native library before using:
//
// - avoid using of "OpenCVLoader.initAsync()" approach - it is deprecated
//   It may load library with different version (from OpenCV Android Manager, which is installed separatelly on device)
//
// - use "System.loadLibrary("opencv_Java3")" or "OpenCVLoader.initDebug()"
//   TODO: Add accurate API to load OpenCV native library
//
//
//
// Native C++ support (necessary to use OpenCV in native code of application only):
//
// - Use find_package() in app/CMakeLists.txt:
//
//   find_package(OpenCV 3.4 REQUIRED Java)
//   ...
//   target_link_libraries(native-lib ${OpenCV_LIBRARIES})
//
// - Add "OpenCV_DIR" and enable C++ exceptions/RTTI support via app/build.gradle
//   Documentation about CMake options: https://developer.Android.com/ndk/guides/cmake.html
//
//   defaultConfig {
//       ...
//       externalNativeBuild {
//           cmake {
//               cppFlags "-std=c++11 -frtti -fexceptions"
//               arguments "-DOpenCV_DIR=" + opencvsdk + "/sdk/native/jni" // , "-DANDROID_ARM_NEON=TRUE"
//           }
//       }
//   }
//
// - (optional) Limit/filter ABIs to build ('Android' scope of 'app/build.gradle'):
//   Useful information: https://developer.Android.com/studio/build/gradle-tips.html (Configure separate APKs per ABI)
//
//   splits {
//       abi {
//           enable true
//           reset()
//           include 'armeabi-v7a' // , 'x86', 'x86_64', 'arm64-v8a'
//           universalApk false
//       }
//   }
//

apply plugin: 'com.Android.library'

println "OpenCV: " + project.buildscript.sourceFile

Android {
    compileSdkVersion 27
    //buildToolsVersion "27.0.3" // not needed since com.Android.tools.build:gradle:3.0.0

    defaultConfig {
        minSdkVersion 14
        targetSdkVersion 21
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-Android.txt'), 'proguard-rules.txt'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_6
        targetCompatibility JavaVersion.VERSION_1_6
    }

    sourceSets {
        main {
            jniLibs.srcDirs = ['native/libs']
            Java.srcDirs = ['Java/src']
            aidl.srcDirs = ['Java/src']
            res.srcDirs = ['Java/res']
            manifest.srcFile 'Java/AndroidManifest.xml'
        }
    }
}

dependencies {
}
2
W1M0R

J'ai importé le projet Java d'OpenCV SDK dans un projet Android Studio Gradle et je l'ai mis à disposition à l'adresse https: //github.com/ctodobom/OpenCV-3.1.0-Android

Vous pouvez l'inclure dans votre projet en ajoutant seulement deux lignes dans build.gradle fichier grâce au service jitpack.io.

2
allgood

Les autorisations et fonctionnalités suivantes sont nécessaires dans le fichier AndroidManifest.xml sans lequel vous obtiendrez la boîte de dialogue suivante.

"Il semble que votre appareil ne supporte pas la caméra (ou il est verrouillé). L'application sera fermée"

  <uses-permission Android:name="Android.permission.CAMERA"/>

    <uses-feature Android:name="Android.hardware.camera" Android:required="false"/>
    <uses-feature Android:name="Android.hardware.camera.autofocus" Android:required="false"/>
    <uses-feature Android:name="Android.hardware.camera.front" Android:required="false"/>
    <uses-feature Android:name="Android.hardware.camera.front.autofocus" Android:required="false"/>
1
Swadesh

OpenCV, Android Studio 1.4.1, module d'extension expérimental 0.2.1

Aucune des autres réponses ne m'a aidé. Voici ce qui a fonctionné pour moi. J'utilise l'exemple tutorial-1 de l'opencv mais je vais utiliser NDK dans mon projet, donc j'utilise le plugin gradle-experimental qui a une structure différente de celle du plugin gradle.

Le studio Android doit être installé, le Android NDK doit être installé via le Android SDK Manager et le OpenCV Android SDK doit être téléchargé et décompressé.

Ceci est en morceaux de script bash pour le garder compact mais complet. Tout est également en ligne de commande car l'un de mes gros problèmes était que les instructions in-IDE étaient obsolètes à mesure que IDE évoluait.

Commencez par définir l'emplacement du répertoire racine du SDK OpenCV.

export OPENCV_SDK=/home/user/wip/OpenCV-2.4.11-Android-sdk
cd $OPENCV_SDK

Créez vos fichiers de construction gradle ...

D'abord la bibliothèque OpenCV

cat > $OPENCV_SDK/sdk/Java/build.gradle <<'==='


apply plugin: 'com.Android.model.library'
model {
    Android {
        compileSdkVersion = 23
        buildToolsVersion = "23.0.2"

        defaultConfig.with {
            minSdkVersion.apiLevel = 8
            targetSdkVersion.apiLevel = 23
        }
    }

    Android.buildTypes {
        release {
            minifyEnabled = false
        }
        debug{
            minifyEnabled = false
        }
    }
   Android.sources {
       main.manifest.source.srcDirs +=  "."
       main.res.source.srcDirs +=  "res"
       main.aidl.source.srcDirs +=  "src"
       main.Java.source.srcDirs +=  "src"
   }

}


===

Indiquez ensuite à l'exemple du didacticiel comment étiqueter la bibliothèque et où la trouver.

cat > $OPENCV_SDK/samples/tutorial-1-camerapreview/settings.gradle <<'==='


include ':openCVLibrary2411'
project(':openCVLibrary2411').projectDir = new File('../../sdk/Java')


===

Créez le fichier de construction pour le tutoriel.

cat > $OPENCV_SDK/samples/tutorial-1-camerapreview/build.gradle <<'==='


buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.Android.tools.build:gradle-experimental:0.2.1'
    }
}

allprojects {
    repositories {
        jcenter()
    }
}

apply plugin: 'com.Android.model.application'

model {
    Android {
        compileSdkVersion = 23
        buildToolsVersion = "23.0.2"

        defaultConfig.with {
            applicationId = "org.opencv.samples.tutorial1"
            minSdkVersion.apiLevel = 8
            targetSdkVersion.apiLevel = 23
        }
    }

    Android.sources {
       main.manifest.source.srcDirs +=  "."
       main.res.source.srcDirs +=  "res"
       main.aidl.source.srcDirs +=  "src"
       main.Java.source.srcDirs +=  "src"
    } 

    Android.buildTypes {
        release {
            minifyEnabled = false
            proguardFiles += file('proguard-rules.pro')
        }
        debug {
             minifyEnabled = false
        }
    }
}

dependencies {
    compile project(':openCVLibrary2411')
}


===

Votre version des outils de construction doit être définie correctement. Voici un moyen facile de voir ce que vous avez installé. (Vous pouvez installer d'autres versions via le Android SDK Manager). Modifiez buildToolsVersion si vous ne possédez pas 23.0.2.

echo "Your buildToolsVersion is one of: "
ls $Android_HOME/build-tools

Changez la variable d'environnement sur la première ligne en votre numéro de version

REP=23.0.2 #CHANGE ME
sed -i.bak s/23\.0\.2/${REP}/g $OPENCV_SDK/sdk/Java/build.gradle
sed -i.bak s/23\.0\.2/${REP}/g $OPENCV_SDK/samples/tutorial-1-camerapreview/build.gradle

Enfin, configurez le bon emballage. Gradle a besoin d'un répertoire propre pour le faire.

pushd $(mktemp -d)

gradle wrapper --gradle-version 2.5

mv -f gradle* $OPENCV_SDK/samples/tutorial-1-camerapreview
popd

Vous devriez maintenant être tous ensemble. Vous pouvez maintenant accéder à ce répertoire avec Android Studio et ouvrir le projet.

Construisez le tutoriel sur la ligne de commande avec la commande suivante:

./gradlew assembleDebug

Il devrait construire votre apk, en le mettant dans ./build/outputs/apk

0
hauptmech