在客戶端開發(fā)過程中，我們可能會遇到這樣一種需求：點擊某個按鈕彈出一個彈窗，提示我們可以更新到apk的某個版本，或者我們可以通過服務(wù)端接口進(jìn)行強制更新。在這種需求中，我們是不需要通過應(yīng)用商店來更新我們的apk的，而是直接在apk內(nèi)部進(jìn)行版本更新。這次我們就來看看實現(xiàn)這種應(yīng)用內(nèi)更新的幾種方式。當(dāng)然，這種玩法只能在國內(nèi)玩，海外的話會被Googleplay據(jù)審的。如果是海外的應(yīng)用要更新apk，只能在GooglePlay上上傳新版本的包。

全量更新

什么是全量更新呢？舉個例子，假設(shè)現(xiàn)在用戶手機上的apk是1.0版本，如果想要升級到2.0版本，全量更新的處理方式則是把2.0版本的apk全部下載下來進(jìn)行覆蓋安裝。那么，我們該如果設(shè)計一個合理的全量更新方案呢？

• 服務(wù)端
  需要提供一個接口，這個接口返回來的body中包含新版本的包的下載地址以及該包的md5值用于下載完成之后進(jìn)行校驗用
• 客戶端
  訪問該服務(wù)端接口，下載新版本的包(其實就是字節(jié)流的讀寫)，然后進(jìn)行覆蓋安裝

做完上面這2點其實就可以實現(xiàn)一個較為完整的全量更新功能。

客戶端核心代碼如下：

package com.mvp.myapplication.update;

import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.PackageManager;
import android.content.pm.ProviderInfo;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Binder;
import android.os.Build;
import android.os.Environment;
import android.os.IBinder;
import android.text.TextUtils;
import android.util.Log;

import androidx.core.content.FileProvider;

import com.mvp.myapplication.utils.MD5Util;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class UpdateService extends Service {

    public static final String KEY_MD5 = "MD5";
    public static final String URL = "downloadUrl";


    private boolean startDownload;//開始下載
    public static final String TAG = "UpdateService";
    private DownloadApk downloadApkTask;
    private String downloadUrl;
    private String mMd5;
    private UpdateProgressListener updateProgressListener;
    private LocalBinder localBinder = new LocalBinder();

    public class LocalBinder extends Binder {
        public void setUpdateProgressListener(UpdateProgressListener listener) {
            UpdateService.this.setUpdateProgressListener(listener);
        }
    }

    private void setUpdateProgressListener(UpdateProgressListener listener) {
        this.updateProgressListener = listener;
    }

    /**
     * 獲取FileProvider的auth
     */
    private static String getFileProviderAuthority(Context context) {
        try {
            for (ProviderInfo provider : context.getPackageManager().getPackageInfo(context.getPackageName(), PackageManager.GET_PROVIDERS).providers) {
                if (FileProvider.class.getName().equals(provider.name) && provider.authority.endsWith(".update_app.file_provider")) {
                    return provider.authority;
                }
            }
        } catch (PackageManager.NameNotFoundException ignore) {
        }
        return null;
    }

    private static Intent installIntent(Context context, String path) {
        Intent intent = new Intent(Intent.ACTION_VIEW);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.addCategory(Intent.CATEGORY_DEFAULT);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            Uri fileUri = FileProvider.getUriForFile(context, getFileProviderAuthority(context), new File(path));
            intent.setDataAndType(fileUri, "application/vnd.android.package-archive");
            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
        } else {
            intent.setDataAndType(Uri.fromFile(new File(path)), "application/vnd.android.package-archive");
        }
        return intent;
    }

    public UpdateService() {
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (!startDownload && intent != null) {
            startDownload = true;
            mMd5 = intent.getStringExtra(KEY_MD5);
            downloadUrl = intent.getStringExtra(URL);

            downloadApkTask = new DownloadApk(this, mMd5);
            downloadApkTask.execute(downloadUrl);

        }
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return localBinder;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        return true;
    }

    @Override
    public void onDestroy() {
        if (downloadApkTask != null) {
            downloadApkTask.cancel(true);
        }
        if (updateProgressListener != null) {
            updateProgressListener = null;
        }
        super.onDestroy();
    }

    private static String getSaveFileName(String downloadUrl) {
        if (downloadUrl == null || TextUtils.isEmpty(downloadUrl)) {
            return System.currentTimeMillis() + ".apk";
        }
        return downloadUrl.substring(downloadUrl.lastIndexOf("/"));
    }

    private static File getDownloadDir(UpdateService service) {
        File downloadDir = null;
        if (Environment.getExternalStorageDirectory().equals(Environment.MEDIA_MOUNTED)) {
            downloadDir = new File(service.getExternalCacheDir(), "update");
        } else {
            downloadDir = new File(service.getCacheDir(), "update");
        }
        if (!downloadDir.exists()) {
            downloadDir.mkdirs();
        }
        return downloadDir;
    }

    private void start() {
        if (updateProgressListener != null) {
            updateProgressListener.start();
        }
    }

    private void update(int progress) {
        if (updateProgressListener != null) {
            updateProgressListener.update(progress);
        }
    }

    private void success(String path) {
        if (updateProgressListener != null) {
            updateProgressListener.success(path);
        }
        Intent i = installIntent(this, path);
        startActivity(i);//自動安裝
        stopSelf();
    }

    private void error() {
        if (updateProgressListener != null) {
            updateProgressListener.error();
        }
        stopSelf();
    }

    private static class DownloadApk extends AsyncTask<String, Integer, String> {
        private final String md5;
        private UpdateService updateService;

        public DownloadApk(UpdateService service, String md5) {
            this.updateService = service;
            this.md5 = md5;
        }

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            if (updateService != null) {
                updateService.start();
            }
        }

        @Override
        protected String doInBackground(String... strings) {
            final String downloadUrl = strings[0];

            final File file = new File(UpdateService.getDownloadDir(updateService),
                    UpdateService.getSaveFileName(downloadUrl));

            Log.d(TAG, "download url is " + downloadUrl);
            Log.d(TAG, "download apk cache at " + file.getAbsolutePath());

            File dir = file.getParentFile();
            if (!dir.exists()) {
                dir.mkdirs();
            }

            HttpURLConnection httpConnection = null;
            InputStream is = null;
            FileOutputStream fos = null;
            long updateTotalSize = 0;
            URL url;
            try {
                url = new URL(downloadUrl);
                httpConnection = (HttpURLConnection) url.openConnection();
                httpConnection.setConnectTimeout(20000);
                httpConnection.setReadTimeout(20000);

                Log.d(TAG, "download status code: " + httpConnection.getResponseCode());


                if (httpConnection.getResponseCode() != 200) {
                    return null;
                }

                updateTotalSize = httpConnection.getContentLength();

                if (file.exists()) {
                    if (updateTotalSize == file.length()) {
                        // 下載完成
                        if (TextUtils.isEmpty(md5) || MD5Util.getMD5String(file).toUpperCase().equals(md5.toUpperCase())) {
                            return file.getAbsolutePath();
                        }
                    } else {
                        file.delete();
                    }
                }
                file.createNewFile();
                is = httpConnection.getInputStream();
                fos = new FileOutputStream(file, false);
                byte buffer[] = new byte[4096];

                int readSize = 0;
                long currentSize = 0;

                while ((readSize = is.read(buffer)) > 0) {
                    fos.write(buffer, 0, readSize);
                    currentSize += readSize;
                    publishProgress((int) (currentSize * 100 / updateTotalSize));
                }
                // download success
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            } finally {
                if (httpConnection != null) {
                    httpConnection.disconnect();
                }
                if (is != null) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            try {
                if (TextUtils.isEmpty(md5) || MD5Util.getMD5String(file).toUpperCase().equals(md5.toUpperCase())) {
                    return file.getAbsolutePath();
                }
            } catch (IOException e) {
                e.printStackTrace();
                return file.getAbsolutePath();
            }
            Log.e(TAG, "md5 invalid");
            return null;
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            if (updateService != null) {
                updateService.update(values[0]);
            }
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            if (updateService != null) {
                if (s != null) {
                    updateService.success(s);
                } else {
                    updateService.error();
                }
            }
        }
    }

    public static class Builder {
        private String downloadUrl;
        private String md5;
        private ServiceConnection serviceConnection;

        protected Builder(String downloadUrl) {
            this.downloadUrl = downloadUrl;
        }

        public static Builder create(String downloadUrl) {
            if (downloadUrl == null) {
                throw new NullPointerException("downloadUrl == null");
            }
            return new Builder(downloadUrl);
        }

        public String getMd5() {
            return md5;
        }

        public Builder setMd5(String md5) {
            this.md5 = md5;
            return this;
        }

        public Builder build(Context context, UpdateProgressListener listener) {
            if (context == null) {
                throw new NullPointerException("context == null");
            }
            Intent intent = new Intent();
            intent.setClass(context, UpdateService.class);
            intent.putExtra(URL, downloadUrl);
            intent.putExtra(KEY_MD5, md5);

            UpdateProgressListener delegateListener = new UpdateProgressListener() {
                @Override
                public void start() {
                    if (listener != null) {
                        listener.start();
                    }
                }

                @Override
                public void update(int var1) {
                    if (listener != null) {
                        listener.update(var1);
                    }
                }

                @Override
                public void success(String path) {
                    try {
                        context.unbindService(serviceConnection);
                    } catch (Throwable t) {
                        Log.e("UpdateService", "解綁失敗" + t.getMessage());
                    }

                    if (listener != null) {
                        listener.success(path);
                    }
                }

                @Override
                public void error() {
                    try {
                        context.unbindService(serviceConnection);
                    } catch (Throwable t) {
                        Log.e("UpdateService", "解綁失敗" + t.getMessage());
                    }
                    if (listener != null) {
                        listener.error();
                    }
                }
            };
            serviceConnection = new ServiceConnection() {
                @Override
                public void onServiceConnected(ComponentName name, IBinder service) {
                    LocalBinder binder = (LocalBinder) service;
                    binder.setUpdateProgressListener(delegateListener);
                }

                @Override
                public void onServiceDisconnected(ComponentName name) {
                }
            };
            context.bindService(intent, serviceConnection, Context.BIND_IMPORTANT);
            context.startService(intent);
            return this;
        }
    }

    public interface UpdateProgressListener {
        void start();

        void update(int var);

        void success(String path);

        void error();
    }
}

package com.mvp.myapplication;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.mvp.myapplication.update.UpdateService;

public class MainActivity extends AppCompatActivity {
    private Button btnAllUpdate, btnAddUpdate, btnHotUpdate;

    private String url,md5;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        btnAddUpdate = findViewById(R.id.btn_add_update);
        btnAllUpdate = findViewById(R.id.btn_all_update);
        btnHotUpdate = findViewById(R.id.btn_hot_update);

        Log.e("MainActivity","onCreate");

        btnAllUpdate.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                UpdateService.Builder.create(url)
                        .setMd5(md5)
                        .build(MainActivity.this, new UpdateService.UpdateProgressListener() {
                            @Override
                            public void start() {
                                Log.e("MainActivity", "start");
                            }

                            @Override
                            public void update(int var) {
                                Log.e("MainActivity", "update ===> " + var);
                            }

                            @Override
                            public void success(String path) {
                                Log.e("MainActivity", "success ===> " + path);
                            }

                            @Override
                            public void error() {
                                Log.e("MainActivity", "error");
                            }
                        });
            }
        });
    }
}

• AndroidManifest

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.MyApplication"
        tools:targetApi="31">
        <service
            android:name=".update.UpdateService"
            android:enabled="true"
            android:exported="true"></service>

        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

            <meta-data
                android:name="android.app.lib_name"
                android:value="" />
        </activity>
        <!-- Android7以上需要 -->
        <provider
            android:name="androidx.core.content.FileProvider"
            android:authorities="${applicationId}.update_app.file_provider"
            android:exported="false"
            android:grantUriPermissions="true"
            tools:replace="android:authorities">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/update_app_path" />
        </provider>
    </application>

</manifest>

• update_app_path

<?xml version="1.0" encoding="utf-8"?>
<paths>
    <cache-path
        name="update_app_cache_files"
        path="/update" />
    <external-path
        name="update_app_external_files"
        path="/" />
    <external-cache-path
        name="update_app_external_cache_files"
        path="/update" />
</paths>

熱更新

嚴(yán)格意義上來說，個人認(rèn)為熱更新并不是用來進(jìn)行包體升級，更多的用來進(jìn)行修復(fù)bug的。例如，由于某個程序員的失誤，在某個類中拋出了一個空指針異常，導(dǎo)致程序執(zhí)行到該類后一直崩潰。這種情況下，其實就可以使用熱更新來處理。因為，我們并沒有大改app中的功能，只是某個類報錯了。但個人認(rèn)為熱更新其實也不能解決所有的奔潰問題的，這些黑科技或多或少都是有一些兼容性的問題的，像Tinker就必須要冷啟動才能修復(fù)，而且受限于Android的版本。
具體是技術(shù)實現(xiàn)方式可以參考筆者之前寫的一篇博客：Android熱修復(fù)1以及Android熱更新十：自己寫一個Android熱修復(fù)

增量更新

什么是增量更新呢？舉了例子，假設(shè)我們需要將apk從v1.0升級到v2.0，這時我們可以通過全量更新的方式，下載2.0版本的apk然后進(jìn)行覆蓋安裝。但是，一般情況下2.0版本的apk往往包含了1.0版本的功能，理論上我們只需要下載二者的差分包，然后將差分包與1.0版本的包進(jìn)行合并即可生成一個2.0版本的包。這樣做的好處自然就是節(jié)約了流量了。像幾乎所有的應(yīng)用商店都使用增量更新的方式來更新apk。那么，我們該我們使用增量更新呢？這個就要借助一個工具：bsdiff。
注意：如果想要使用增量更新，那么必須要有一個舊版本的apk，如果用戶安裝完apk后直接把舊版本的apk刪掉了，那么還是老老實實使用全量更新的方式吧。

• 拆——拆分出差分包

bsdiff oldfile newfile1 patchfile

• 合——將舊版本的包與差分包進(jìn)行合并

bspatch oldfile newfile2 patchfile

使用上面兩步便可以完成差分包的拆分與合并，新生成的newfile2 與newfile1的md5是一致的。但是上面這兩步法我們是在pc端進(jìn)行的，我們該如何在代碼中實現(xiàn)上面的邏輯呢？首先，拆分的邏輯還是在pc端中進(jìn)行，客戶端只需要關(guān)注如何合并差分包。
首先，我們需要導(dǎo)入bspatch相關(guān)的類

接著，我們新建一個類用于調(diào)用c相關(guān)的代碼：

package com.mvp.myapplication.utils;

public class BSPatchUtil {

    // Used to load the 'native-lib' library on application startup.
    static {
        System.loadLibrary("bspatch");
    }

    /**
     * native方法 使用路徑為oldApkPath的apk與路徑為patchPath的補丁包，合成新的apk，并存儲于newApkPath
     *
     * 返回：0，說明操作成功
     *
     * @param oldApkPath 示例:/sdcard/old.apk
     * @param outputApkPath 示例:/sdcard/output.apk
     * @param patchPath  示例:/sdcard/xx.patch
     * @return
     */
    public static native int bspatch(String oldApkPath, String outputApkPath,
                                   String patchPath);

}

package com.mvp.myapplication;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.os.Environment;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.mvp.myapplication.update.UpdateService;
import com.mvp.myapplication.utils.BSPatchUtil;

import java.io.File;

public class MainActivity extends AppCompatActivity {
    private Button btnAllUpdate, btnAddUpdate, btnHotUpdate;

    private String url, md5;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        btnAddUpdate = findViewById(R.id.btn_add_update);
        btnAllUpdate = findViewById(R.id.btn_all_update);
        btnHotUpdate = findViewById(R.id.btn_hot_update);

        Log.e("MainActivity", "onCreate");

        btnAllUpdate.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                UpdateService.Builder.create(url)
                        .setMd5(md5)
                        .build(MainActivity.this, new UpdateService.UpdateProgressListener() {
                            @Override
                            public void start() {
                                Log.e("MainActivity", "start");
                            }

                            @Override
                            public void update(int var) {
                                Log.e("MainActivity", "update ===> " + var);
                            }

                            @Override
                            public void success(String path) {
                                Log.e("MainActivity", "success ===> " + path);
                            }

                            @Override
                            public void error() {
                                Log.e("MainActivity", "error");
                            }
                        });
            }
        });

        btnAddUpdate.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                genNewApk();
            }
        });
    }

    private void genNewApk() {
        String oldpath = getApplicationInfo().sourceDir;
        String newpath = (this.getCacheDir().getAbsolutePath()+ File.separator
                + "composed_hivebox_apk.apk");

        String patchpath = (this.getCacheDir().getAbsolutePath()+ File.separator
                + "bs_patch");
        Log.e("MainActivity", "oldpath is " + oldpath + "\n newpath is " + newpath + "\n patchpath is " + patchpath);
        BSPatchUtil.bspatch(oldpath, newpath, patchpath);

    }
}

注意：需要修改bspatch.c文件中的Java_com_mvp_myapplication_utils_BSPatchUtil_bspatch方法簽名：改為BSPatchUtil 的包名，例如BSPatchUtil對應(yīng)的路徑為com.dxl.testbatch.util.BSPatchUtil，那么native方法簽名就是Java_com_mvp_myapplication_utils_BSPatchUtil_bspatch
這樣便可以通過jni調(diào)用到c層面的代碼。

接著，修改build.gradle文件，添加下面圈中的閉包

最后，我們執(zhí)行Make Project命令，正常情況下便可以生成如下幾個so庫

最后，我們在把so庫放入jniLibs文件夾中，然后build下生成apk包

然后，我們將差分包bs_patch放入手機的data/data目錄下，點擊按鈕就會生成composed_hivebox_apk.apk這個apk包，將其與v2.0的包進(jìn)行MD5對比，發(fā)現(xiàn)是一致的。如此，我們便實現(xiàn)了一個簡單的增量更新邏輯。
Demo地址：https://gitee.com/hzulwy/add_-update/tree/master/MyApplication文章來源地址http://www.zghlxwxcb.cn/news/detail-654381.html

到了這里，關(guān)于Android中的全量更新、增量更新以及熱更新的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！