打包jar文件 外部調用資源 so等

一個非常好的從jar文件中加載so動態庫方法，在android的gif支持開源中用到。這個項目的gif解碼是用jni c實現的，避免了OOM等問題。

項目地址：https://github.com/koral--/android-gif-drawable

如果是把java文件生成jar。jni生成的so文件放到使用apk的libs/armeabi/lib_gif.so.....

gifExample.apk:

/libs/gif.jar

/libs/armeabi/lib_gi.so

這樣做會報錯，提示xml里面找不到GifImageView。

只能用項目之間依賴，so會自動進入生成的apk，不用拷貝。

 

調用方法：

//開始調用：
    static {
        LibraryLoader.loadLibrary(null, LibraryLoader.BASE_LIBRARY_NAME);
    }

進入這里：

package pl.droidsonroids.gif;

import android.content.Context;
import android.support.annotation.NonNull;

import java.lang.reflect.Method;

/**
 * Helper used to work around native libraries loading on some systems.
 * See <a href="https://medium.com/keepsafe-engineering/the-perils-of-loading-native-libraries-on-android-befa49dce2db">ReLinker</a> for more details.
 */
public class LibraryLoader {
    static final String SURFACE_LIBRARY_NAME = "pl_droidsonroids_gif_surface";
    static final String BASE_LIBRARY_NAME = "pl_droidsonroids_gif";
    private static Context sAppContext;

    /**
     * Intitializes loader with given `Context`. Subsequent calls should have no effect since application Context is retrieved.
     * Libraries will not be loaded immediately but only when needed.
     * @param context any Context except null
     */
    public static void initialize(@NonNull final Context context) {
        sAppContext = context.getApplicationContext();
    }

    static Context getContext() {
        if (sAppContext == null) {
            try {
                final Class<?> activityThread = Class.forName("android.app.ActivityThread");
                final Method currentApplicationMethod = activityThread.getDeclaredMethod("currentApplication");
                sAppContext = (Context) currentApplicationMethod.invoke(null);
            } catch (Exception e) {
                throw new RuntimeException("LibraryLoader not initialized. Call LibraryLoader.initialize() before using library classes.", e);
            }
        }
        return sAppContext;
    }

    static void loadLibrary(Context context, final String library) {
        try {
            System.loadLibrary(library);
        } catch (final UnsatisfiedLinkError e) {
            if (SURFACE_LIBRARY_NAME.equals(library)) {
                loadLibrary(context, BASE_LIBRARY_NAME);
            }
            if (context == null) {
                context = getContext();
            }
            ReLinker.loadLibrary(context, library);
        }
    }
}

 

最終到這里：

 

/**
 * Copyright 2015 KeepSafe Software, Inc.
 * <p/>
 * 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
 * <p/>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p/>
 * 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.
 */
package pl.droidsonroids.gif;

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.os.Build;

import java.io.Closeable;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

/**
 * Based on https://github.com/KeepSafe/ReLinker
 * ReLinker is a small library to help alleviate {@link UnsatisfiedLinkError} exceptions thrown due
 * to Android's inability to properly install / load native libraries for Android versions before
 * API 21
 */
class ReLinker {
    private static final String LIB_DIR = "lib";
    private static final int MAX_TRIES = 5;
    private static final int COPY_BUFFER_SIZE = 8192;

    private ReLinker() {
        // No instances
    }

    /**
     * Utilizes the regular system call to attempt to load a native library. If a failure occurs,
     * then the function extracts native .so library out of the app's APK and attempts to load it.
     * <p/>
     * <strong>Note: This is a synchronous operation</strong>
     */
    static void loadLibrary(Context context, final String library) {
        final String libName = System.mapLibraryName(library);
        synchronized (ReLinker.class) {
            final File workaroundFile = unpackLibrary(context, libName);
            System.load(workaroundFile.getAbsolutePath());
        }
    }

    /**
     * Attempts to unpack the given library to the workaround directory. Implements retry logic for
     * IO operations to ensure they succeed.
     *
     * @param context {@link Context} to describe the location of the installed APK file
     * @param libName The name of the library to load
     */
    private static File unpackLibrary(final Context context, final String libName) {
        File outputFile = new File(context.getDir(LIB_DIR, Context.MODE_PRIVATE), libName);// + BuildConfig.VERSION_NAME);
        if (outputFile.isFile()) {
            return outputFile;
        }

        final File cachedLibraryFile = new File(context.getCacheDir(), libName );//+ BuildConfig.VERSION_NAME);
        if (cachedLibraryFile.isFile()) {
            return cachedLibraryFile;
        }

        final FilenameFilter filter = new FilenameFilter() {
            @Override
            public boolean accept(File dir, String filename) {
                return filename.startsWith(libName);
            }
        };
        clearOldLibraryFiles(outputFile, filter);
        clearOldLibraryFiles(cachedLibraryFile, filter);

        final ApplicationInfo appInfo = context.getApplicationInfo();
        final File apkFile = new File(appInfo.sourceDir);
        ZipFile zipFile = null;
        try {
            zipFile = openZipFile(apkFile);

            int tries = 0;
            while (tries++ < MAX_TRIES) {
                ZipEntry libraryEntry = getLibraryEntry(libName, zipFile);

                InputStream inputStream = null;
                FileOutputStream fileOut = null;
                try {
                    inputStream = zipFile.getInputStream(libraryEntry);
                    fileOut = new FileOutputStream(outputFile);
                    copy(inputStream, fileOut);
                } catch (IOException e) {
                    if (tries > MAX_TRIES / 2) {
                        outputFile = cachedLibraryFile;
                    }
                    continue;
                } finally {
                    closeSilently(inputStream);
                    closeSilently(fileOut);
                }
                setFilePermissions(outputFile);
                break;
            }
        } finally {
            closeSilently(zipFile);
        }
        return outputFile;
    }

    @SuppressWarnings("deprecation") //required for old API levels
    private static ZipEntry getLibraryEntry(final String libName, final ZipFile zipFile) {
        String jniNameInApk;

        ZipEntry libraryEntry = null;
//        if (Build.VERSION.SDK_INT >= 21 && Build.SUPPORTED_ABIS.length > 0) {
//            for (final String ABI : Build.SUPPORTED_ABIS) {
//                jniNameInApk = "lib/" + ABI + "/" + libName;
//                libraryEntry = zipFile.getEntry(jniNameInApk);
//
//                if (libraryEntry != null) {
//                    break;
//                }
//            }
//        } else 
        
        {
            jniNameInApk = "lib/" + Build.CPU_ABI + "/" + libName;
            libraryEntry = zipFile.getEntry(jniNameInApk);
        }

        if (libraryEntry == null) {
            throw new IllegalStateException("Library " + libName + " for supported ABIs not found in APK file");
        }
        return libraryEntry;
    }

    private static ZipFile openZipFile(final File apkFile) {
        int tries = 0;
        ZipFile zipFile = null;
        while (tries++ < MAX_TRIES) {
            try {
                zipFile = new ZipFile(apkFile, ZipFile.OPEN_READ);
                break;
            } catch (IOException ignored) {
            }
        }

        if (zipFile == null) {
            throw new RuntimeException("Could not open APK file: " + apkFile.getAbsolutePath());
        }
        return zipFile;
    }

    @SuppressWarnings("ResultOfMethodCallIgnored") //intended, nothing useful can be done
    private static void clearOldLibraryFiles(final File outputFile, final FilenameFilter filter) {
        final File[] fileList = outputFile.getParentFile().listFiles(filter);
        if (fileList != null) {
            for (File file : fileList) {
                file.delete();
            }
        }
    }

    @SuppressWarnings("ResultOfMethodCallIgnored") //intended, nothing useful can be done
    @SuppressLint("SetWorldReadable") //intended, default permission
    private static void setFilePermissions(File outputFile) {
        // Try change permission to rwxr-xr-x
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
            outputFile.setReadable(true, false);
            outputFile.setExecutable(true, false);
            outputFile.setWritable(true);
        }
    }

    /**
     * Copies all data from an {@link InputStream} to an {@link OutputStream}.
     *
     * @param in  The stream to read from.
     * @param out The stream to write to.
     * @throws IOException when a stream operation fails.
     */
    private static void copy(InputStream in, OutputStream out) throws IOException {
        final byte[] buf = new byte[COPY_BUFFER_SIZE];
        while (true) {
            final int bytesRead = in.read(buf);
            if (bytesRead == -1) {
                break;
            }
            out.write(buf, 0, bytesRead);
        }
    }

    /**
     * Closes a {@link Closeable} silently (without throwing or handling any exceptions)
     *
     * @param closeable {@link Closeable} to close
     */
    private static void closeSilently(final Closeable closeable) {
        try {
            if (closeable != null) {
                closeable.close();
            }
        } catch (IOException ignored) {
        }
    }
}

獲取當前apk路徑

final ApplicationInfo appInfo = context.getApplicationInfo();
Log.d("zhibin","appInfo.sourceDir: "+ appInfo.sourceDir);
輸出：/system/app/xxx.apk

---

對應sdk 5.0以下版本，修正一些不支持的變量：

    @SuppressWarnings("deprecation") //required for old API levels
    private static ZipEntry getLibraryEntry(final String libName, final ZipFile zipFile) {
        String jniNameInApk;

        ZipEntry libraryEntry = null;
//        if (Build.VERSION.SDK_INT >= 21 && Build.SUPPORTED_ABIS.length > 0) {
//            for (final String ABI : Build.SUPPORTED_ABIS) {
//                jniNameInApk = "lib/" + ABI + "/" + libName;
//                libraryEntry = zipFile.getEntry(jniNameInApk);
//
//                if (libraryEntry != null) {
//                    break;
//                }
//            }
//        } else 
        
        {
            jniNameInApk = "lib/" + Build.CPU_ABI + "/" + libName;
            Log.d("zhibin","Search directory for jniNameInApk: "+ jniNameInApk);
            libraryEntry = zipFile.getEntry(jniNameInApk);
            
            
            //直接指定
            if(libraryEntry == null){
                jniNameInApk = "lib/armeabi" + "/" + libName;
                Log.d("zhibin","Correct it to  jniNameInApk: "+ jniNameInApk);
                libraryEntry = zipFile.getEntry(jniNameInApk);
            }
        }

        if (libraryEntry == null) {
            throw new IllegalStateException("Library " + libName + " for supported ABIs not found in APK file");
        }
        return libraryEntry;
    }

 

 

 

 

 

 

 

 

 

 

共外部調用資源：

 

背景：工作中需要開發一個廣告插件，並提供給其它人使用。這里就需要把自己的插件程序，打成jar來提供給他人引用。
但是遇到一個問題：插件程序中無法使用資源文件。

試過以下幾種方式解決：

1、從插件程序中導出jar包
論壇上有人說導出的jar包中無法包含Drawable等資源文件，一些圖片等數據，需要放到Assert文件中使用。
其實，關於這個問題，我做了嘗試：
首先，需要說明導出jar包含什么文件是由你導出時選擇來決定的，比如下圖：

如果你選擇了res文件夾，則打包出的jar文件是可以包含res文件到。

但是包含文件並不代表可以使用。如果你想當然在插件程序中使用R.drawable.XXXX等方式獲取
資源會報錯！
當然別人通過R.XX.XX也只能看到自己的資源文件，而無法獲取jar中的資源文件。

2、獲取jar包中的文件

雖然無法直接引用資源文件，但是如果外邊程序想獲取某個資源文件時，也是可行的。
其原理是以數據流讀取jar中指定的文件。
比如讀取Assert文件下的icon.jpg文件：
你可以在插件中封裝一個對外的方法：
    publicstatic Drawable getAssertDrawable(Context context,StringfileName){
       try {
          InputStreaminStream=context.getAssets().open(fileName);
          return newBitmapDrawable(BitmapFactory.decodeStream(inStream));
       } catch(IOException e) {
         Log.e(LOG_TAG, "Assert中"+fileName+"不存在");
       }
       returnnull;
    }
直接使用該方法可以得到文件。
后來又嘗試在外部程序，直接使用context.getAssets().open(fileName)方法獲取jar中文件，
讓人喜出望外的是竟然成功了。呵呵！
后來分析，外部程序編譯時，其實連同jar包中內容一起混編。jar包中的Assert文件會同外部程序的Assert一起
由AssertManager管理。
所以當你jar包中Assert內部文件和外部Assert中的文件有命名沖突時，編譯器會報錯的。

另外，還有人提供另外一種方法來讀取諸如Drawable等文件夾下的文件。
    publicstatic Drawable getDrawableForJar(String resName，Classclass){
       InputStreaminStream=class.getResourceAsStream(resName);
       return newBitmapDrawable(BitmapFactory.decodeStream(inStream));
    }
使用class.getResourceAsStream()方法讀取，注意這里resName是文件的相對路徑，比如jar根目錄下res/drawable/icon.png，
則調用方法為：class.getResourceAsStream(/res/drawable/icon.png);

這里主要是采用ClassLoader的下面幾個方法來實現：

　　public URL getResource(String name);

　　public InputStream getResourceAsStream(String name)

　　public static InputStreamgetSystemResourceAsStream(String name)

　　public static URL getSystemResource(String name)

　　后兩個方法可以看出是靜態的方法，這幾個方法都可以從Jar中讀取圖片資源，但是對與動畫的gif文件，筆者在嘗試過程中發現，存在一些差異。

　　String gifName為Gif文件在Jar中的相對路徑。

　　(1)使用了兩個靜態方法

　　BufferedImageimage = ImageIO.read(ClassLoader.getSystemResourceAsStream(gifName));

　　或者

　　Image image = Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource(gifName));

　　這兩種方式可以成功地讀取gif文件，但是對於gif動畫，顯示出來地是靜態的。

　　(2)使用其他兩個方法

　　Image image = Toolkit.getDefaultToolkit().getImage( this .getClass.getClassLoader()

.getResource(gifName));

　　再這種方式下動畫可以正常顯示了。

3、使用library方法加載資源文件 

在論壇中看到帖子講述如何把工程作為libarary,讓其他工程添加library，編譯后會自動生成jar，然后在哪來使用。 
當時看到此貼，喜出望外，所以趕緊嘗試下！ 

方法：選擇插件工程，右鍵選擇屬性，選擇Android，勾選下面Is Liabrary選項。 
然后，選擇我們現有的工程，右鍵屬性，選擇Android，在library下add相應的庫。你會看到，剛才我們設置的插件項目，就在其中。最后，點擊應用，完成。 

詳細步驟： 

按如下方法設置：

1. 假設要引用的android工程叫LibProject，引入到的工程叫MainProject；

2.設置LibProject，右鍵->Properties->Android，將Islibrary項選中，然后Apply；

3.設置MainProject，右鍵->->Properties->Android,在Library中，點擊Add按鈕，將LibProject工程加入，Apply即可。

你會看到我們的工程中多出插件工程的引用，而且可以使用R.XXX.XXX獲取資源文件。 

以為可以解決了，但是發現並沒有生成想要的jar文件。在插件工程中，倒是有編譯的class文件，卻沒有jar包。 
而我們往往是不能像這樣把原工程給別人直接引用的。 
經過多次試驗，始終沒有生成jar,非常奇怪別人怎么弄得。。。 

另外，拿以前通過這種方式生成的jar文件看，里面也不包含資源文件夾。。 
可以把生成的類共享出去。

把.so文件打包到jar中

查了一些方法，其中一個我比較喜歡，再load動態庫的時候，把so文件復制到tmp目錄下，然后刪掉

//modify the static block static { try { Class c = HelloJNI.class; URL location = c.getProtectionDomain().getCodeSource().getLocation(); ZipFile zf = new ZipFile(location.getPath()); // libhellojni.so is put in the lib folder InputStream in = zf.getinputStream(zf.getEntry("lib/libhellojni.so")); File f = File.createTempFile("JNI-", "Temp"); FileOutputStream out = new FileOutputStream(f); byte [] buf = new byte[1024]; int len; while ((len = in.read(buf)) > 0) out.write(buf, 0, len); in.close(); out.close(); System.load(f.getAbsolutePath()); f.delete(); } catch (Exception e) { // I am still lazy ~~~ e.printStackTrace(); } }