share Image

android/build.gradle

@@ -2,7 +2,7 @@ group 'com.jarvanmo.wechatplugin'
 version '1.0-SNAPSHOT'
 
 buildscript {
-    ext.kotlin_version = '1.2.51'
+    ext.kotlin_version = '1.2.60'
     repositories {
         google()
         jcenter()
@@ -40,10 +40,11 @@ android {
 }
 
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk:$kotlin_version"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation 'com.tencent.mm.opensdk:wechat-sdk-android-with-mta:+'
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.24.0'
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-common:0.24.0'
+//    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-common:0.24.0'
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:0.24.0'
     implementation 'top.zibin:Luban:1.1.8'
+    implementation 'com.squareup.okhttp3:okhttp:3.11.0'
 }

android/src/main/kotlin/com/jarvanmo/wechatplugin/AppRegister.java

@@ -15,6 +15,5 @@ public class AppRegister extends BroadcastReceiver {
 		final IWXAPI api = WXAPIFactory.createWXAPI(context, null);
 		// 将该app注册到微信
 		api.registerApp(WechatPluginConfig.appId);
-
 	}
 }

android/src/main/kotlin/com/jarvanmo/wechatplugin/WechatPlugin.kt

@@ -11,10 +11,14 @@ import io.flutter.plugin.common.PluginRegistry.Registrar
 
 class WechatPlugin(private var channel: MethodChannel,private var registrar: Registrar) : MethodCallHandler {
     companion object {
+        @JvmStatic
+        val TAG = "WeChatPlugin"
+        val FILE_NOT_EXIST = "file not exists"
+
         @JvmStatic
         fun registerWith(registrar: Registrar): Unit {
             val channel = MethodChannel(registrar.messenger(), "wechat_plugin")
-            WeChatPluginHandler.setContext(registrar.context().applicationContext)
+            WeChatPluginHandler.setRegistrar(registrar)
             channel.setMethodCallHandler(WechatPlugin(channel,registrar))
             WeChatPluginHandler.setMethodChannel(channel)
         }
@@ -31,7 +35,9 @@ class WechatPlugin(private var channel: MethodChannel,private var registrar: Reg
                 result.error("config your wxapi first", "config your wxapi first", null)
                 return
             }
-            else -> WeChatPluginHandler.handle(call, result)
+            call.method.startsWith("share")->{
+                WeChatPluginHandler.handle(call, result)
+            }
         }
 
 

android/src/main/kotlin/com/jarvanmo/wechatplugin/config/WeChatPluginImageSchema.java

+package com.jarvanmo.wechatplugin.config;
+
+public class WeChatPluginImageSchema {
+    public static  final String SCHEMA_ASSETS ="assets://";
+    public static final  String SCHMEA_HTTP = "http://";
+    public static final  String SCHMEA_HTTPS = "https://";
+    public static final String SCHMEA_FILE = "file://";
+}

android/src/main/kotlin/com/jarvanmo/wechatplugin/config/WechatPluginConfig.java

@@ -16,4 +16,6 @@ public class WechatPluginConfig {
 
     public static final String TEXT = "text";
 
+    public static final String IMAGE ="image";
+    public static final String THUMBNAIL ="thumbnail";
 }

android/src/main/kotlin/com/jarvanmo/wechatplugin/handler/WeChatPluginHandler.kt

 package com.jarvanmo.wechatplugin.handler
 
-import android.annotation.SuppressLint
-import android.content.Context
+import android.graphics.BitmapFactory
+import android.util.Log
+import com.jarvanmo.wechatplugin.WechatPlugin
+import com.jarvanmo.wechatplugin.config.WeChatPluginImageSchema
 import com.jarvanmo.wechatplugin.config.WeChatPluginMethods
 import com.jarvanmo.wechatplugin.config.WechatPluginConfig
+import com.jarvanmo.wechatplugin.utils.AssetManagerUtil
+import com.jarvanmo.wechatplugin.utils.FileUtil
+import com.jarvanmo.wechatplugin.utils.WeChatThumbnailUtil
 import com.tencent.mm.opensdk.modelbase.BaseResp
-import com.tencent.mm.opensdk.modelmsg.SendMessageToWX
-import com.tencent.mm.opensdk.modelmsg.WXMediaMessage
-import com.tencent.mm.opensdk.modelmsg.WXMiniProgramObject
-import com.tencent.mm.opensdk.modelmsg.WXTextObject
+import com.tencent.mm.opensdk.modelmsg.*
 import com.tencent.mm.opensdk.openapi.IWXAPI
 import io.flutter.plugin.common.MethodCall
 import io.flutter.plugin.common.MethodChannel
-import top.zibin.luban.Luban
+import io.flutter.plugin.common.PluginRegistry
+import java.io.File
+import java.net.URL
 
 
-@SuppressLint("StaticFieldLeak")
 /***
  * Created by mo on 2018/8/8
  * 冷风如刀，以大地为砧板，视众生为鱼肉。
@@ -26,7 +29,7 @@ object WeChatPluginHandler {
 
     private var channel: MethodChannel? = null
 
-    private var context: Context? = null
+    private var registrar: PluginRegistry.Registrar? = null
 
 
     fun apiIsNull() = wxApi == null
@@ -39,38 +42,37 @@ object WeChatPluginHandler {
         this.wxApi = wxApi
     }
 
-    fun setContext(context: Context){
-        this.context = context.applicationContext
+    fun setRegistrar(registrar: PluginRegistry.Registrar) {
+        this.registrar = registrar
     }
 
 
     fun handle(call: MethodCall, result: MethodChannel.Result) {
         when (call.method) {
-            WeChatPluginMethods.SHARE_TEXT -> shareText(call)
-            WeChatPluginMethods.SHARE_MINI_PROGRAM -> shareMiniProgram(call)
+            WeChatPluginMethods.SHARE_TEXT -> shareText(call,result)
+            WeChatPluginMethods.SHARE_MINI_PROGRAM -> shareMiniProgram(call, result)
+            WeChatPluginMethods.SHARE_IMAGE -> shareImage(call, result)
             else -> {
                 result.notImplemented()
             }
         }
     }
 
-    private fun shareText(call: MethodCall) {
-
+    private fun shareText(call: MethodCall, result: MethodChannel.Result) {
         val textObj = WXTextObject()
         textObj.text = call.argument(WechatPluginConfig.TEXT)
         val msg = WXMediaMessage()
         msg.mediaObject = textObj
         msg.description = call.argument(WechatPluginConfig.TEXT)
         val req = SendMessageToWX.Req()
-        req.transaction = call.argument(WechatPluginConfig.TRANSACTION)
         req.message = msg
-        req.scene = getScene(call.argument(WechatPluginConfig.SCENE))
+        setCommonArguments(call,req)
         wxApi?.sendReq(req)
-
+        result.success(true)
     }
 
 
-    private  fun shareMiniProgram(call: MethodCall){
+    private fun shareMiniProgram(call: MethodCall, result: MethodChannel.Result) {
         val miniProgramObj = WXMiniProgramObject()
         miniProgramObj.webpageUrl = call.argument("webPageUrl") // 兼容低版本的网页链接
         miniProgramObj.miniprogramType = call.argument("miniProgramType")// 正式版:0，测试版:1，体验版:2
@@ -79,16 +81,69 @@ object WeChatPluginHandler {
         val msg = WXMediaMessage(miniProgramObj)
         msg.title = call.argument("title")                   // 小程序消息title
         msg.description = call.argument("description")               // 小程序消息desc
-//        msg.thumbData = getThumb()                      // 小程序消息封面图片，小于128k
+        var thumbnail: String? = call.argument(WechatPluginConfig.THUMBNAIL)
+        thumbnail = thumbnail ?: ""
+
+        if (thumbnail.isNullOrBlank()) {
+            msg.thumbData = null
+        } else {
+            msg.thumbData = WeChatThumbnailUtil.thumbnailForMiniProgram(thumbnail, registrar)
+        }
 
 
         val req = SendMessageToWX.Req()
-        req.transaction = call.argument("transaction")
+        setCommonArguments(call, req)
         req.message = msg
-        req.scene = call.argument("scene")  // 目前支持会话
-        wxApi.sendReq(req)
+        wxApi?.sendReq(req)
+        result.success(true)
+
+    }
+
+    private fun shareImage(call: MethodCall, result: MethodChannel.Result) {
+        val imagePath = call.argument<String>(WechatPluginConfig.IMAGE)
+        val imgObj = createWxImageObject(imagePath)
+        if (imgObj == null) {
+            result.error(WechatPlugin.TAG,WechatPlugin.FILE_NOT_EXIST,imagePath)
+            return
+        }
+
+
+//        val bmp = BitmapFactory.decodeResource(getResources(), R.drawable.send_img)
+//        val imgObj = WXImageObject(bmp)
+//
+        val msg = WXMediaMessage()
+        msg.mediaObject = imgObj
+//
+//        val thumbBmp = Bitmap.createScaledBitmap(bmp, THUMB_SIZE, THUMB_SIZE, true)
+//        bmp.recycle()
+        msg.thumbData = WeChatThumbnailUtil.thumbnailForCommon(call.argument(WechatPluginConfig.THUMBNAIL), registrar)
+//
+        val req = SendMessageToWX.Req()
+        setCommonArguments(call,req)
+//        req.message = msg
+        wxApi?.sendReq(req)
+        result.success(true)
     }
 
+    private fun createWxImageObject(imagePath:String):WXImageObject?{
+        var imgObj: WXImageObject? = null
+        var imageFile:File? = null
+        if (imagePath.startsWith(WeChatPluginImageSchema.SCHEMA_ASSETS)){
+            val key = imagePath.substring(WeChatPluginImageSchema.SCHEMA_ASSETS.length, imagePath.length)
+            val assetFileDescriptor = AssetManagerUtil.openAsset(registrar,key,"")
+            imageFile  = FileUtil.createTmpFile(assetFileDescriptor)
+        }else if (imagePath.startsWith(WeChatPluginImageSchema.SCHMEA_FILE)){
+            imageFile = File(imagePath)
+        }
+        if(imageFile != null && imageFile.exists()){
+            imgObj = WXImageObject()
+            imgObj.setImagePath(imagePath)
+        }else{
+            Log.d(WechatPlugin.TAG,WechatPlugin.FILE_NOT_EXIST)
+        }
+
+        return  imgObj
+    }
     fun onResp(resp: BaseResp) {
         val result = mapOf(
                 "errStr" to resp.errStr,
@@ -104,13 +159,16 @@ object WeChatPluginHandler {
 
     }
 
-    private fun getScene(value: String) = when (value) {
+    private fun getScene(value: String) = when (value.toLowerCase()) {
         WechatPluginConfig.TIMELINE -> SendMessageToWX.Req.WXSceneTimeline
         WechatPluginConfig.SESSION -> SendMessageToWX.Req.WXSceneSession
         WechatPluginConfig.FAVORITE -> SendMessageToWX.Req.WXSceneFavorite
         else -> SendMessageToWX.Req.WXSceneTimeline
-
     }
 
+    private fun setCommonArguments(call: MethodCall, req: SendMessageToWX.Req) {
+        req.transaction = call.argument(WechatPluginConfig.TRANSACTION)
+        req.scene = getScene(call.argument(WechatPluginConfig.SCENE))
+    }
 
 }
\ No newline at end of file

android/src/main/kotlin/com/jarvanmo/wechatplugin/utils/AssetManagerUtil.java

+package com.jarvanmo.wechatplugin.utils;
+
+import android.content.res.AssetFileDescriptor;
+import android.content.res.AssetManager;
+
+import java.io.IOException;
+
+import io.flutter.plugin.common.PluginRegistry;
+
+public final class AssetManagerUtil {
+    private AssetManagerUtil(){
+        throw  new RuntimeException("can't do this");
+    }
+
+    public static   AssetFileDescriptor openAsset(PluginRegistry.Registrar registrar, String assetKey, String assetPackage) {
+        AssetFileDescriptor fd = null;
+        AssetManager assetManager = registrar.context().getAssets();
+        String key = registrar.lookupKeyForAsset(assetKey, assetPackage);
+        try {
+            fd = assetManager.openFd(key);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return fd;
+    }
+}

android/src/main/kotlin/com/jarvanmo/wechatplugin/utils/CompressImageUtil.java

+package com.jarvanmo.wechatplugin.utils;
+
+import android.content.Context;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import top.zibin.luban.Luban;
+
+class CompressImageUtil {
+    private CompressImageUtil(){}
+
+    public static File compressUtilSmallerThan(int size,File file,Context context){
+
+        File result = null;
+        File tmp = file;
+        List<File> dirtyFiles = new ArrayList<>();
+        try {
+
+            while (tmp.length() > size * 1024){
+                List<File> compressedFiles = Luban.with(context)
+                        .ignoreBy(size)
+                        .load(tmp)
+                        .setTargetDir(context.getCacheDir().getAbsolutePath())
+                        .get();
+                tmp = compressedFiles.get(0);
+                dirtyFiles.add(tmp);
+            }
+
+            result = tmp;
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        for (File dirtyFile : dirtyFiles) {
+            if(dirtyFile != result){
+                dirtyFile.delete();
+            }
+        }
+        return  result;
+    }
+}

android/src/main/kotlin/com/jarvanmo/wechatplugin/utils/FileUtil.java

+package com.jarvanmo.wechatplugin.utils;
+
+import android.content.res.AssetFileDescriptor;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.UUID;
+
+import okio.BufferedSink;
+import okio.Okio;
+import okio.Source;
+
+public class FileUtil {
+    public static File createTmpFile(AssetFileDescriptor fileDescriptor ){
+        if (fileDescriptor == null) {
+            return  null;
+        }
+        File file = null;
+        BufferedSink sink = null;
+        Source source= null;
+        OutputStream outputStream = null;
+        try {
+            file = File.createTempFile(UUID.randomUUID().toString(),".png");
+            outputStream = new FileOutputStream(file);
+            sink = Okio.buffer(Okio.sink(outputStream));
+            source = Okio.source(fileDescriptor.createInputStream());
+            sink.writeAll(source);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }finally {
+            if(sink != null){
+                try {
+                    sink.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            if (source != null) {
+                try {
+                    source.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            if (outputStream != null) {
+                try {
+                    outputStream.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        return  file;
+    }
+}

android/src/main/kotlin/com/jarvanmo/wechatplugin/utils/Util.java

+package com.jarvanmo.wechatplugin.utils;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.RandomAccessFile;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.security.MessageDigest;
+
+import junit.framework.Assert;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Bitmap.CompressFormat;
+import android.util.Log;
+
+public class Util {
+	
+	private static final String TAG = "SDK_Sample.Util";
+	
+	public static byte[] bmpToByteArray(final Bitmap bmp, final boolean needRecycle) {
+		ByteArrayOutputStream output = new ByteArrayOutputStream();
+		bmp.compress(CompressFormat.PNG, 100, output);
+		if (needRecycle) {
+			bmp.recycle();
+		}
+		
+		byte[] result = output.toByteArray();
+		try {
+			output.close();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		
+		return result;
+	}
+	
+	public static byte[] getHtmlByteArray(final String url) {
+		 URL htmlUrl = null;     
+		 InputStream inStream = null;     
+		 try {         
+			 htmlUrl = new URL(url);         
+			 URLConnection connection = htmlUrl.openConnection();         
+			 HttpURLConnection httpConnection = (HttpURLConnection)connection;         
+			 int responseCode = httpConnection.getResponseCode();         
+			 if(responseCode == HttpURLConnection.HTTP_OK){             
+				 inStream = httpConnection.getInputStream();         
+			  }     
+			 } catch (MalformedURLException e) {               
+				 e.printStackTrace();     
+			 } catch (IOException e) {              
+				e.printStackTrace();    
+		  } 
+		byte[] data = inputStreamToByte(inStream);
+
+		return data;
+	}
+	
+	public static byte[] inputStreamToByte(InputStream is) {
+		try{
+			ByteArrayOutputStream bytestream = new ByteArrayOutputStream();
+			int ch;
+			while ((ch = is.read()) != -1) {
+				bytestream.write(ch);
+			}
+			byte imgdata[] = bytestream.toByteArray();
+			bytestream.close();
+			return imgdata;
+		}catch(Exception e){
+			e.printStackTrace();
+		}
+		
+		return null;
+	}
+	
+	public static byte[] readFromFile(String fileName, int offset, int len) {
+		if (fileName == null) {
+			return null;
+		}
+
+		File file = new File(fileName);
+		if (!file.exists()) {
+			Log.i(TAG, "readFromFile: file not found");
+			return null;
+		}
+
+		if (len == -1) {
+			len = (int) file.length();
+		}
+
+		Log.d(TAG, "readFromFile : offset = " + offset + " len = " + len + " offset + len = " + (offset + len));
+
+		if(offset <0){
+			Log.e(TAG, "readFromFile invalid offset:" + offset);
+			return null;
+		}
+		if(len <=0 ){
+			Log.e(TAG, "readFromFile invalid len:" + len);
+			return null;
+		}
+		if(offset + len > (int) file.length()){
+			Log.e(TAG, "readFromFile invalid file len:" + file.length());
+			return null;
+		}
+
+		byte[] b = null;
+		try {
+			RandomAccessFile in = new RandomAccessFile(fileName, "r");
+			b = new byte[len]; // ���������ļ���С������
+			in.seek(offset);
+			in.readFully(b);
+			in.close();
+
+		} catch (Exception e) {
+			Log.e(TAG, "readFromFile : errMsg = " + e.getMessage());
+			e.printStackTrace();
+		}
+		return b;
+	}
+	
+	private static final int MAX_DECODE_PICTURE_SIZE = 1920 * 1440;
+	public static Bitmap extractThumbNail(final String path, final int height, final int width, final boolean crop) {
+		Assert.assertTrue(path != null && !path.equals("") && height > 0 && width > 0);
+
+		BitmapFactory.Options options = new BitmapFactory.Options();
+
+		try {
+			options.inJustDecodeBounds = true;
+			Bitmap tmp = BitmapFactory.decodeFile(path, options);
+			if (tmp != null) {
+				tmp.recycle();
+				tmp = null;
+			}
+
+			Log.d(TAG, "extractThumbNail: round=" + width + "x" + height + ", crop=" + crop);
+			final double beY = options.outHeight * 1.0 / height;
+			final double beX = options.outWidth * 1.0 / width;
+			Log.d(TAG, "extractThumbNail: extract beX = " + beX + ", beY = " + beY);
+			options.inSampleSize = (int) (crop ? (beY > beX ? beX : beY) : (beY < beX ? beX : beY));
+			if (options.inSampleSize <= 1) {
+				options.inSampleSize = 1;
+			}
+
+			// NOTE: out of memory error
+			while (options.outHeight * options.outWidth / options.inSampleSize > MAX_DECODE_PICTURE_SIZE) {
+				options.inSampleSize++;
+			}
+
+			int newHeight = height;
+			int newWidth = width;
+			if (crop) {
+				if (beY > beX) {
+					newHeight = (int) (newWidth * 1.0 * options.outHeight / options.outWidth);
+				} else {
+					newWidth = (int) (newHeight * 1.0 * options.outWidth / options.outHeight);
+				}
+			} else {
+				if (beY < beX) {
+					newHeight = (int) (newWidth * 1.0 * options.outHeight / options.outWidth);
+				} else {
+					newWidth = (int) (newHeight * 1.0 * options.outWidth / options.outHeight);
+				}
+			}
+
+			options.inJustDecodeBounds = false;
+
+			Log.i(TAG, "bitmap required size=" + newWidth + "x" + newHeight + ", orig=" + options.outWidth + "x" + options.outHeight + ", sample=" + options.inSampleSize);
+			Bitmap bm = BitmapFactory.decodeFile(path, options);
+			if (bm == null) {
+				Log.e(TAG, "bitmap decode failed");
+				return null;
+			}
+
+			Log.i(TAG, "bitmap decoded size=" + bm.getWidth() + "x" + bm.getHeight());
+			final Bitmap scale = Bitmap.createScaledBitmap(bm, newWidth, newHeight, true);
+			if (scale != null) {
+				bm.recycle();
+				bm = scale;
+			}
+
+			if (crop) {
+				final Bitmap cropped = Bitmap.createBitmap(bm, (bm.getWidth() - width) >> 1, (bm.getHeight() - height) >> 1, width, height);
+				if (cropped == null) {
+					return bm;
+				}
+
+				bm.recycle();
+				bm = cropped;
+				Log.i(TAG, "bitmap croped size=" + bm.getWidth() + "x" + bm.getHeight());
+			}
+			return bm;
+
+		} catch (final OutOfMemoryError e) {
+			Log.e(TAG, "decode bitmap failed: " + e.getMessage());
+			options = null;
+		}
+
+		return null;
+	}
+}

android/src/main/kotlin/com/jarvanmo/wechatplugin/utils/WeChatThumbnailUtil.java

+package com.jarvanmo.wechatplugin.utils;
+
+import android.content.res.AssetFileDescriptor;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+
+import com.jarvanmo.wechatplugin.config.WeChatPluginImageSchema;
+
+import java.io.File;
+import java.io.IOException;
+
+import io.flutter.plugin.common.PluginRegistry;
+import okio.Okio;
+import okio.Source;
+
+public class WeChatThumbnailUtil {
+    private static final int COMMON_THUMB_SIZE = 150;
+    
+    private WeChatThumbnailUtil() {
+    }
+
+    public static byte[] thumbnailForMiniProgram(String thumbnail, PluginRegistry.Registrar registrar) {
+        byte[] result = null;
+        if (thumbnail.startsWith(WeChatPluginImageSchema.SCHEMA_ASSETS)) {
+          result = fromAssetForMiniProgram(thumbnail,registrar);
+        }
+        return result;
+    }
+
+
+
+    private static byte[] fromAssetForMiniProgram(String thumbnail, PluginRegistry.Registrar registrar){
+        byte[] result = null;
+        String key = thumbnail.substring(WeChatPluginImageSchema.SCHEMA_ASSETS.length(), thumbnail.length());
+        AssetFileDescriptor fileDescriptor = AssetManagerUtil.openAsset(registrar, key, "");
+
+        if (fileDescriptor != null && fileDescriptor.getLength() <= 128 * 1024) {
+            try {
+                Source source = Okio.source(fileDescriptor.createInputStream());
+                result = Okio.buffer(source).readByteArray();
+                source.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else if (fileDescriptor != null && fileDescriptor.getLength() > 128 * 1024) {
+            File file = FileUtil.createTmpFile(fileDescriptor);
+            if (file == null) {
+                return null;
+            }
+            File snapshot = CompressImageUtil.compressUtilSmallerThan(128, file, registrar.context());
+            if (snapshot == null) {
+                return null;
+            }
+
+            try {
+                result = Okio.buffer(Okio.source(snapshot)).readByteArray();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+        }
+
+        return  result;
+    }
+
+    public static byte[] thumbnailForCommon(String thumbnail, PluginRegistry.Registrar registrar){
+        byte[] result = null;
+        if (thumbnail.startsWith(WeChatPluginImageSchema.SCHEMA_ASSETS)) {
+            result = fromAssetForCommon(thumbnail,registrar);
+        }
+        return result;
+    }
+
+    private static byte[] fromAssetForCommon(String thumbnail, PluginRegistry.Registrar registrar){
+        int size = 32;
+        byte[] result = null;
+        String key = thumbnail.substring(WeChatPluginImageSchema.SCHEMA_ASSETS.length(), thumbnail.length());
+        AssetFileDescriptor fileDescriptor = AssetManagerUtil.openAsset(registrar, key, "");
+
+        if (fileDescriptor != null && fileDescriptor.getLength() <= size * 1024) {
+            try {
+                Source source = Okio.source(fileDescriptor.createInputStream());
+                result = Okio.buffer(source).readByteArray();
+                source.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else if (fileDescriptor != null && fileDescriptor.getLength() > size * 1024) {
+            File file = FileUtil.createTmpFile(fileDescriptor);
+            if (file == null) {
+                return null;
+            }
+            File snapshot = CompressImageUtil.compressUtilSmallerThan(size, file, registrar.context());
+            if (snapshot == null) {
+                return null;
+            }
+
+            try {
+                result = Okio.buffer(Okio.source(snapshot)).readByteArray();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+        }
+
+//        Bitmap bmp = BitmapFactory.decodeStream(new URL(url).openStream());
+//        Bitmap thumbBmp = Bitmap.createScaledBitmap(bmp, COMMON_THUMB_SIZE, COMMON_THUMB_SIZE, true);
+//        bmp.recycle();
+//       result = Util.bmpToByteArray(thumbBmp, true);
+        return  result;
+    }
+}

example/android/build.gradle

 buildscript {
-    ext.kotlin_version = '1.1.51'
+    ext.kotlin_version = '1.2.60'
     repositories {
         google()
         jcenter()

example/lib/main.dart

@@ -18,6 +18,7 @@ class _MyAppState extends State<MyApp> {
   void initState() {
     super.initState();
     initPlatformState();
+
   }
 
   // Platform messages are asynchronous, so we initialize in an async method.

lib/src/wechat_share_models.dart

 import 'package:wechat_plugin/src/wechat_scene.dart';
 
+const String _scene = "scene";
+const String _transaction = "transaction";
+const String _thumbnail = "thumbnail";
+
 class WeChatShareTextModel {
   final String text;
   final String transaction;
@@ -11,17 +15,11 @@ class WeChatShareTextModel {
         this.scene = scene ?? WeChatScene.TIMELINE;
 
   Map toMap() {
-    return {
-      "text": text,
-      "transaction": transaction,
-      "scene": scene.toString()
-    };
+    return {"text": text, _transaction: transaction, _scene: scene.toString()};
   }
 }
 
-
-
-class WeChatMiniProgramModel {
+class WeChatShareMiniProgramModel {
   static const int MINI_PROGRAM_TYPE_RELEASE = 0;
   static const int MINI_PROGRAM_TYPE_TEST = 1;
   static const int MINI_PROGRAM_TYPE_PREVIEW = 2;
@@ -41,32 +39,56 @@ class WeChatMiniProgramModel {
 
   final String thumbnail;
 
-  WeChatMiniProgramModel(
+  WeChatShareMiniProgramModel(
       {this.webPageUrl,
       int miniProgramType,
       this.userName,
       this.path,
       this.title,
       this.description,
-        this.thumbnail,
+      this.thumbnail,
       String transaction})
       : this.transaction = transaction ?? "miniProgram",
-      this.miniProgramType = miniProgramType??MINI_PROGRAM_TYPE_RELEASE,
-      assert(webPageUrl != null && webPageUrl.isNotEmpty),
-      assert(userName != null && userName.isNotEmpty)    ,
-      assert(path != null && path.isNotEmpty );
+        this.miniProgramType = miniProgramType ?? MINI_PROGRAM_TYPE_RELEASE,
+        assert(webPageUrl != null && webPageUrl.isNotEmpty),
+        assert(userName != null && userName.isNotEmpty),
+        assert(path != null && path.isNotEmpty);
 
-  Map toMap(){
+  Map toMap() {
+    return {
+      'webPageUrl': webPageUrl,
+      "miniProgramType": miniProgramType,
+      "userName": userName,
+      "path": path,
+      "title": title,
+      "description": description,
+      _transaction: transaction,
+      _scene: scene,
+      _thumbnail: thumbnail
+    };
+  }
+}
+
+class WeChatShareImageModel {
+  final String transaction;
+  final WeChatScene scene;
+  final String image;
+  final String thumbnail;
+
+  WeChatShareImageModel(
+      {String transaction, WeChatScene scene, this.image, String thumbnail})
+      : this.transaction = transaction ?? "text",
+        this.scene = scene ?? WeChatScene.TIMELINE,
+        this.thumbnail = thumbnail ?? "",
+        assert(image != null),
+        assert(thumbnail != null);
+
+  Map toMap() {
     return {
-      'webPageUrl':webPageUrl,
-      "miniProgramType":miniProgramType,
-      "userName":userName,
-      "path":path,
-      "title":title,
-      "description":description,
-      "transaction":transaction,
-      "scene":scene,
-      "thumbnail":thumbnail
+      _transaction: transaction,
+      _scene: scene.toString(),
+      "image": image,
+      _thumbnail: thumbnail
     };
   }
 }

lib/wechat_plugin.dart

@@ -31,7 +31,7 @@ class WechatPlugin {
     return await _channel.invokeMethod("shareText",model.toMap());
   }
 
-  static Future shareMiniProgram(WeChatMiniProgramModel model)async{
+  static Future shareMiniProgram(WeChatShareMiniProgramModel model)async{
     return await _channel.invokeMethod("shareMiniProgram",model.toMap());
   }