备案控制台
开发者社区 开发与运维 文章 正文

【Android 组件化】使用 ARoute 实现组件化 ( 完整组件化项目框架 )

2022-02-01 475
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【Android 组件化】使用 ARoute 实现组件化 ( 完整组件化项目框架 )

一、ARoute 引入


使用 ARouter 第三方库实现组件化 : https://github.com/alibaba/ARouter


ARoute 是阿里的开源库 ;


创建项目 , 项目中有 3 33 个 Module , 1 11 个主模块 app , 2 22 个依赖库 module1 和 module2 ;

9.png



在 app , module1 , module2 , 3 33 个模块的 build.gradle 中 , 都要进行如下配置 ;



在 build.gradle 下的 " android / defaultConfig " 层级添加配置 :


android {
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [AROUTER_MODULE_NAME: project.getName()]
            }
        }
    }
}


在 build.gradle 下的 " dependencies " 层级添加 ARoute 依赖 :


// 替换成最新版本, 需要注意的是api
    // 要与compiler匹配使用，均使用最新版可以保证兼容
    api 'com.alibaba:arouter-api:1.5.1'
    annotationProcessor 'com.alibaba:arouter-compiler:1.5.1'


3 33 模块间的依赖关系 : app 模块依赖剩余两个模块 , 模块之间不发生依赖关系 ;

implementation project(path: ':module1')
implementation project(path: ':module2')

二、3 个模块的界面跳转


1、app 模块注解、app 跳转到 module1 模块


app 模块 : 使用 @Route(path = "/app/MainActivity") 注解标注 Activity 类 , 界面按钮点击方法跳转到 module1 中的 Activity 界面中 ;



代码示例 :


package kim.hsl.component;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import com.alibaba.android.arouter.facade.annotation.Route;
import com.alibaba.android.arouter.launcher.ARouter;
// 在支持路由的页面上添加注解(必选)
// 这里的路径需要注意的是至少需要有两级，/xx/xx
@Route(path = "/app/MainActivity")
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public void onClick(View view) {
        Log.i(TAG, "跳转到 Module1");
        ARouter.getInstance().build("/module1/Module1Activity").navigation();
        finish();
    }
}



2、module1 模块注解、module1 跳转到 module2 模块


module1 模块跳转到 module2 模块 , 这两个模块之间互相没有依赖关系 ;


module1 模块使用 @Route(path = "/module1/Module1Activity") 注解标注 ,



代码示例 :


package kim.hsl.module1;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import com.alibaba.android.arouter.facade.annotation.Route;
import com.alibaba.android.arouter.launcher.ARouter;
@Route(path = "/module1/Module1Activity")
public class Module1Activity extends AppCompatActivity {
    private static final String TAG = "Module1Activity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_module1);
    }
    public void onClick(View view) {
        Log.i(TAG, "跳转到 Module2");
        ARouter.getInstance().build("/module2/Module2Activity").navigation();
        finish();
    }
}


3、module2 模块注解、module2 跳转到 app 模块


代码示例 :


package kim.hsl.module2;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import com.alibaba.android.arouter.facade.annotation.Route;
import com.alibaba.android.arouter.launcher.ARouter;
@Route(path = "/module2/Module2Activity")
public class Module2Activity extends AppCompatActivity {
    private static final String TAG = "Module2Activity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_module2);
    }
    public void onClick(View view) {
        Log.i(TAG, "跳转到 app");
        ARouter.getInstance().build("/app/MainActivity").navigation();
        finish();
    }
}


4、跳转效果


20210529133239910.gif






三、组件化配置


1、全局配置


全局配置 :


isModuleMode 是最终要的配置 , 通过该配置的 true / false 设置当前是否开启组件化 ,


集成模式 true ( 默认模式 , 模块化 )

组件模式 false ( 组件化 )

androidConfig 用于统一管理各个 Module 中的版本号 , 如编译版本号 , 最小版本号 , 目标版本号 ;


applicationId 用于保存各个模块的包名 , 尤其是 module 依赖库的包名 , 组件化的状态下 , 该 module 需要独立运行 , 必须配置一个 applicationId 包名 ;


dependencies 用于统一管理各个模块之间的依赖库 , 避免管理分散 ;


// ext 是 extension 扩展的含义
// ext 后的 {} 花括号 , 是闭包 ,
ext{
    // 是否是模块化模式
    // 集成模式 true ( 默认模式 , 模块化 )
    // 组件模式 false ( 组件化 )
    isModuleMode = true
    // 定义 android 变量 , 类型是字典 Map 集合
    // 其中定义了若干键值对集合
    androidConfig = [
            compileSdkVersion : 30,
            minSdkVersion : 18,
            targetSdkVersion : 30,
            versionCode : 1,
            versionName : "1.0"
    ]
    applicationId = [
            "app" : "kim.hsl.component",
            "module1" : "kim.hsl.module1",
            "module2" : "kim.hsl.module2",
    ]
    // androidx 版本号
    androidxVersion = "1.3.0"
    constraintlayoutVersion = "2.0.4"
    materialVersion = "1.3.0"
    // 统一管理依赖库
    dependencies = [
            // ${} 表示引用之前定义的变量
            "appcompat" : "androidx.appcompat:appcompat:${androidxVersion}",
            "constraintlayout" : "androidx.constraintlayout:constraintlayout:${constraintlayoutVersion}",
            "material" : "com.google.android.material:material:${materialVersion}"
    ]
}



2、工程下的 build.gradle 配置


在总的 build.gradle 配置中 , 引入上述全局配置 , 其作用就相当于将上述全局配置原封不动拷贝过来 ;


apply from: "component.gradle"

1


完整配置 :


// Top-level build file where you can add configuration options common to all sub-projects/modules.
// 将 component.gradle 配置文件中的内容导入到该位置
// 相当于引入头文件
apply from: "component.gradle"
buildscript {
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath "com.android.tools.build:gradle:4.1.0"
        // 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
}


3、app 模块下的 build.gradle 配置


在 app 模块中重点关注 , 在组件模式下 , 一定不能引入依赖库 , 否则会报错 , 因为组件模式下这两个依赖库是两个可运行的独立应用 ;


dependencies {
    if (isModuleMode){
        // 集成模式下才能引用这两个 Library Module
        implementation project(path: ':module1')
        implementation project(path: ':module2')
    }


版本号 , applicationId , 依赖库 统一管理 :


从 Project 级别的配置中获取变量 :


def androidConfig = rootProject.ext.androidConfig
def appId = rootProject.ext.applicationId
def dep = rootProject.ext.dependencies


版本号 和 applicationId 统一管理 :


android {
    compileSdkVersion androidConfig.compileSdkVersion
    defaultConfig {
        applicationId appId["app"]
        minSdkVersion androidConfig.minSdkVersion
        targetSdkVersion androidConfig.targetSdkVersion
        versionCode androidConfig.versionCode
        versionName androidConfig.versionName
    }


依赖库统一管理 :


dependencies {
    //implementation 'androidx.appcompat:appcompat:1.3.0'
    //implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    //implementation 'com.google.android.material:material:1.3.0'
    implementation dep.appcompat
    implementation dep.constraintlayout
    implementation dep.material
}


完整配置 :


plugins {
    id 'com.android.application'
}
def androidConfig = rootProject.ext.androidConfig
def appId = rootProject.ext.applicationId
def dep = rootProject.ext.dependencies
android {
    compileSdkVersion androidConfig.compileSdkVersion
    buildToolsVersion "30.0.3"
    defaultConfig {
        applicationId appId["app"]
        minSdkVersion androidConfig.minSdkVersion
        targetSdkVersion androidConfig.targetSdkVersion
        versionCode androidConfig.versionCode
        versionName androidConfig.versionName
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        // ARoute 需要的配置
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [AROUTER_MODULE_NAME: project.getName()]
            }
        }
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
dependencies {
    //implementation 'androidx.appcompat:appcompat:1.3.0'
    //implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    //implementation 'com.google.android.material:material:1.3.0'
    implementation dep.appcompat
    implementation dep.constraintlayout
    implementation dep.material
    testImplementation 'junit:junit:4.+'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
    // 替换成最新版本, 需要注意的是api
    // 要与compiler匹配使用，均使用最新版可以保证兼容
    api 'com.alibaba:arouter-api:1.5.1'
    annotationProcessor 'com.alibaba:arouter-compiler:1.5.1'
    if (isModuleMode){
        // 集成模式下才能引用这两个 Library Module
        implementation project(path: ':module1')
        implementation project(path: ':module2')
    }
}



四、Module 模块的组件化配置


Module 模块的配置比较复杂 ;


首先 , Module 模块在组件模式下是可以独立运行的应用 , 必须有一个入口 Activity ; 但是 Module 下的清单文件是这样的 :


<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="kim.hsl.module1">
    <application>
        <activity android:name=".Module1Activity"></activity>
    </application>
</manifest>


这就需要为其单独配置一个清单文件 , 并且还要兼容在组件模式下能适用原来的这个清单文件 ;


此外还需要为其配置 Application 类 , 需要为其单独指定 Java 文件 , 并且在模块化模式中 , 不使用该文件 ;


1、创建组件模式下使用的类和清单文件


在 module1 下创建 组件模式 时使用的 Application 类和清单文件 ;


9.png



Application 类如下 :


package kim.hsl.module1;
import android.app.Application;
public class Module1Application extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
    }
}


清单文件如下 :


<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="kim.hsl.module1">
    <application
        android:name=".Module1Application"
        android:allowBackup="true"
        android:supportsRtl="true"
        android:theme="@style/Theme.MaterialComponents.DayNight.DarkActionBar">
        <activity android:name=".Module1Activity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>


在 build.gradle 中 " android / defaultConfig / sourceSets " 下配置相关资源文件 , 如果在组件模式下 , 使用 manifest.srcFile 配置组件模式下的清单文件 , 使用 java.srcDirs 配置组件模式下使用的 Java 源文件 ;


这些配置在 集成模式 下都失效 , 因此使用 isModuleMode 进行判定当前是 组件模式 还是 集成模式 ;


android {
    defaultConfig {
        if (!isModuleMode){
            // 组件模式 : 必须配置 applicationId
            applicationId appId["module1"]
        }
        // 资源配置
        sourceSets{
            main{
                if (!isModuleMode){
                    // 组件化模式下使用 ComponentAndroidManifest.xml 作为清单文件
                    manifest.srcFile 'src/main/component/AndroidManifest.xml'
                    // 配置额外的 Java 源文件目录
                    java.srcDirs 'src/main/component/java', 'src/main/java'
                }else{
                    // 集成模式 下使用默认设置
                }
            }
        }
  }
}


2、动态切换 集成模式 / 组件模式


在 module 中需要考虑 集成模式 / 组件模式 动态切换问题 , 当 isModuleMode 设置为 true 时 , 当前是集成模式 , module 模块作为 app 模块的依赖库进行编译 , 因此需要加载 apply plugin: 'com.android.library' 插件 ;


当 isModuleMode 设置为 false 时 , 是 组件模式 , 每个 module 都是可以独立运行的应用 , 需要加载 apply plugin: 'com.android.application' 插件 ;



代码示例 :


// 根据 isModuleMode 动态切换 集成模式 / 组件模式
if (isModuleMode){
    // 集成模式
    apply plugin: 'com.android.library'
}else{
    // 组件模式
    apply plugin: 'com.android.application'
}


此外 , 如果是 组件模式 , module 是可以独立运行的应用 , 必须为其配置 applicationId ;


android {
    defaultConfig {
        if (!isModuleMode){
            // 组件模式 : 必须配置 applicationId
            applicationId appId["module2"]
        }
  }
}




3、module1 完整的 build.gradle 配置文件


// 根据 isModuleMode 动态切换 集成模式 / 组件模式
if (isModuleMode){
    // 集成模式
    apply plugin: 'com.android.library'
}else{
    // 组件模式
    apply plugin: 'com.android.application'
}
def androidConfig = rootProject.ext.androidConfig
def appId = rootProject.ext.applicationId
def dep = rootProject.ext.dependencies
android {
    compileSdkVersion androidConfig.compileSdkVersion
    buildToolsVersion "30.0.3"
    defaultConfig {
        if (!isModuleMode){
            // 组件模式 : 必须配置 applicationId
            applicationId appId["module1"]
        }
        minSdkVersion androidConfig.minSdkVersion
        targetSdkVersion androidConfig.targetSdkVersion
        versionCode androidConfig.versionCode
        versionName androidConfig.versionName
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        consumerProguardFiles "consumer-rules.pro"
        // 资源配置
        sourceSets{
            main{
                if (!isModuleMode){
                    // 组件化模式下使用 ComponentAndroidManifest.xml 作为清单文件
                    manifest.srcFile 'src/main/component/AndroidManifest.xml'
                    // 配置额外的 Java 源文件目录
                    java.srcDirs 'src/main/component/java', 'src/main/java'
                }else{
                    // 集成模式 下使用默认设置
                }
            }
        }
        // ARoute 需要的配置
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [AROUTER_MODULE_NAME: project.getName()]
            }
        }
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
dependencies {
    //implementation 'androidx.appcompat:appcompat:1.3.0'
    //implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    //implementation 'com.google.android.material:material:1.3.0'
    implementation dep.appcompat
    implementation dep.constraintlayout
    implementation dep.material
    testImplementation 'junit:junit:4.+'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
    // 替换成最新版本, 需要注意的是api
    // 要与compiler匹配使用，均使用最新版可以保证兼容
    api 'com.alibaba:arouter-api:1.5.1'
    annotationProcessor 'com.alibaba:arouter-compiler:1.5.1'
}



4、module2 完整的 build.gradle 配置文件


module1 与 module2 的配置项基本相同 ;


// 根据 isModuleMode 动态切换 集成模式 / 组件模式
if (isModuleMode){
    // 集成模式
    apply plugin: 'com.android.library'
}else{
    // 组件模式
    apply plugin: 'com.android.application'
}
def androidConfig = rootProject.ext.androidConfig
def appId = rootProject.ext.applicationId
def dep = rootProject.ext.dependencies
android {
    compileSdkVersion androidConfig.compileSdkVersion
    buildToolsVersion "30.0.3"
    defaultConfig {
        if (!isModuleMode){
            // 组件模式 : 必须配置 applicationId
            applicationId appId["module2"]
        }
        minSdkVersion androidConfig.minSdkVersion
        targetSdkVersion androidConfig.targetSdkVersion
        versionCode androidConfig.versionCode
        versionName androidConfig.versionName
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        consumerProguardFiles "consumer-rules.pro"
        // 资源配置
        sourceSets{
            main{
                if (!isModuleMode){
                    // 组件化模式下使用 ComponentAndroidManifest.xml 作为清单文件
                    manifest.srcFile 'src/main/component/AndroidManifest.xml'
                    // 配置额外的 Java 源文件目录
                    java.srcDirs 'src/main/component/java', 'src/main/java'
                }else{
                    // 集成模式 下使用默认设置
                }
            }
        }
        // ARoute 需要的配置
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [AROUTER_MODULE_NAME: project.getName()]
            }
        }
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
dependencies {
    //implementation 'androidx.appcompat:appcompat:1.3.0'
    //implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
    //implementation 'com.google.android.material:material:1.3.0'
    implementation dep.appcompat
    implementation dep.constraintlayout
    implementation dep.material
    testImplementation 'junit:junit:4.+'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
    // 替换成最新版本, 需要注意的是api
    // 要与compiler匹配使用，均使用最新版可以保证兼容
    api 'com.alibaba:arouter-api:1.5.1'
    annotationProcessor 'com.alibaba:arouter-compiler:1.5.1'
}



5、module1 独立运行效果


<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="kim.hsl.module1">
    <application
        android:name=".Module1Application"
        android:allowBackup="true"
        android:supportsRtl="true"
        android:theme="@style/Theme.MaterialComponents.DayNight.DarkActionBar">
        <activity android:name=".Module1Activity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>


清单文件中设置的主题是黑色的 ;

9.png



6、module2 独立运行效果


<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="kim.hsl.module2">
    <application
        android:name=".Module2Application"
        android:allowBackup="true"
        android:supportsRtl="true"
        android:theme="@style/Theme.MaterialComponents.DayNight.DarkActionBar">
        <activity android:name=".Module2Activity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>


清单文件中设置的主题是黑色的 ;


9.png



文章标签：
Java
Android开发
ARouter
关键词：
Android项目
Android框架
Android组件化
Android组件化框架
Android实现
韩曙亮
目录
相关文章
无糖可乐嘟嘟
|
12天前
|
Java 开发工具 Android开发
探索Android与iOS开发的差异：平台选择对项目成功的影响
在移动应用开发的广阔天地中，Android和iOS两大平台各自占据着半壁江山。本文将深入探讨这两个平台在开发过程中的关键差异点，包括编程语言、开发工具、用户界面设计、性能优化以及市场覆盖等方面。通过对这些关键因素的比较分析，旨在为开发者提供一个清晰的指南，帮助他们根据项目需求和目标受众做出明智的平台选择。
无糖可乐嘟嘟
12 0
肥猪肥猪-17824
|
18天前
|
Java Android开发 Swift
探索Android与iOS开发的差异：平台选择对项目成功的影响
【6月更文挑战第18天】在移动应用开发的广阔天地中，Android和iOS两大平台各据一方，它们在市场份额、用户群体及开发环境上各有千秋。本文将深入分析这两个操作系统的开发差异，探讨如何根据项目需求选择合适的平台，并讨论跨平台解决方案的可行性与挑战。我们将通过实际案例，揭示平台选择对项目成功的关键性影响，为开发者提供决策支持。
肥猪肥猪-17824
22 2
蓝色流星86
|
20天前
|
安全 JavaScript 前端开发
kotlin开发安卓app，JetPack Compose框架，给webview新增一个按钮，点击刷新网页
在Kotlin中开发Android应用，使用Jetpack Compose框架时，可以通过添加一个按钮到TopAppBar来实现WebView页面的刷新功能。按钮位于右上角，点击后调用`webViewState?.reload()`来刷新网页内容。以下是代码摘要：
蓝色流星86
56 1
蓝色流星86
|
21天前
|
JavaScript Java Android开发
kotlin安卓在Jetpack Compose 框架下跨组件通讯EventBus
**EventBus** 是一个Android事件总线库，简化组件间通信。要使用它，首先在Gradle中添加依赖`implementation &#39;org.greenrobot:eventbus:3.3.1&#39;`。然后，可选地定义事件类如`MessageEvent`。在活动或Fragment的`onCreate`中注册订阅者，在`onDestroy`中反注册。通过`@Subscribe`注解方法处理事件，如`onMessageEvent`。发送事件使用`EventBus.getDefault().post()`。
蓝色流星86
76 2
蓝色流星86
|
21天前
|
JavaScript 前端开发 Android开发
kotlin安卓在Jetpack Compose 框架下使用webview ， 网页中的JavaScript代码如何与native交互
在Jetpack Compose中使用Kotlin创建Webview组件，设置JavaScript交互：`@Composable`函数`ComposableWebView`加载网页并启用JavaScript。通过`addJavascriptInterface`添加`WebAppInterface`类，允许JavaScript调用Android方法如播放音频。当页面加载完成时，执行`onWebViewReady`回调。
蓝色流星86
42 2
蓝色流星86
|
25天前
|
缓存 Android开发 Kotlin
【安卓app开发】kotlin Jetpack Compose框架 | 先用OKhttp下载远程音频文件再使用ExoPlayer播放
使用 Kotlin 的 Jetpack Compose 开发安卓应用时，可以结合 OkHttp 下载远程音频文件和 ExoPlayer 进行播放。在 `build.gradle` 添加相关依赖后，示例代码展示了如何下载音频并用 ExoPlayer 播放。代码包括添加依赖、下载文件、播放文件及简单的 Compose UI。注意，示例未包含完整错误处理和资源释放，实际应用需补充这些内容。
蓝色流星86
64 5
皮牙子抓饭
|
28天前
|
前端开发 JavaScript 测试技术
使用React框架运行在Android环境上
【6月更文挑战第5天】
皮牙子抓饭
38 4
皮牙子抓饭
|
27天前
|
开发框架 Dart 开发工具
一个Android项目怎么判断是flutter
【6月更文挑战第6天】
皮牙子抓饭
30 2
游客5fdji2pvmf8888
|
1月前
|
Java Android开发 Swift
探索安卓与iOS开发的差异：平台选择对项目成功的影响
在移动应用开发的浩瀚宇宙中，安卓和iOS这两大星系以其独特的引力影响着开发者的航向。本文将穿梭于这两个平台的开发环境、编程语言、用户界面设计、性能优化以及市场分布等方面，揭示它们之间的核心差异。我们将通过比较分析，为开发者提供决策时的参考坐标，帮助他们根据项目需求和目标受众选择合适的平台。加入我们，一起揭开安卓与iOS开发的神秘面纱，探索它们如何塑造移动应用的未来。
游客5fdji2pvmf8888
27 5
米诺斯
|
9天前
|
Java Maven Android开发
安卓项目使用阿里云镜像加速构建过程
安卓项目使用阿里云镜像加速构建过程
米诺斯
8 0