customer / shanghai-railway-rnapp

package com.metroapp.nativemodules;

import android.Manifest;
import android.app.Activity;
import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.location.LocationManager;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.provider.Settings;
import android.support.v4.content.ContextCompat;
import android.text.TextUtils;
import android.widget.Toast;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.sdk.android.oss.ClientException;
import com.alibaba.sdk.android.oss.OSS;
import com.alibaba.sdk.android.oss.ServiceException;
import com.alibaba.sdk.android.oss.callback.OSSCompletedCallback;
import com.alibaba.sdk.android.oss.model.OSSRequest;
import com.alibaba.sdk.android.oss.model.PutObjectRequest;
import com.alibaba.sdk.android.oss.model.PutObjectResult;
import com.allenliu.versionchecklib.core.AllenChecker;
import com.allenliu.versionchecklib.core.VersionParams;
import com.douwan.peacemetro.R;
import com.facebook.react.BuildConfig;
import com.facebook.react.bridge.ActivityEventListener;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.bridge.WritableNativeArray;
import com.facebook.react.bridge.WritableNativeMap;
import com.metroapp.MainApplication;
import com.metroapp.bean.CameraDataBean;
import com.metroapp.constant.Extras;
import com.metroapp.constant.StorageType;
import com.metroapp.forum.AliUploadFileService;
import com.metroapp.forum.FileUtil;
import com.metroapp.forum.RomCheck;
import com.metroapp.forum.StorageUtil;
import com.metroapp.forum.StringUtil;
import com.metroapp.forum.VideoUtils;
import com.metroapp.forum.bean.VideoBean;
import com.metroapp.forum.listener.ActionCallbackListener;
import com.metroapp.forum.load.PhotoPickerManager;
import com.metroapp.forum.location.LocationCallBack;
import com.metroapp.forum.location.LocationChooseActivity;
import com.metroapp.forum.location.XnDeviceApiUtils;
import com.metroapp.forum.location.XnLocation;
import com.metroapp.forum.location.fls.LocationExtraBean;
import com.metroapp.forum.location.fls.LocationPickActivity;
import com.metroapp.forum.location.fls.LocationService;
import com.metroapp.forum.picker.PickImageActivity;
import com.metroapp.forum.view.AuthReqDialog;
import com.metroapp.utils.ToastUtils;
import com.metroapp.utils.XNVersionService;
import com.xiniunet.api.domain.xntalk.City;
import com.xiniunet.api.internal.util.StringUtils;
import com.xiniunet.photobrowser.activity.PhotoBrowserActivity;
import com.yalantis.ucrop.UCrop;
import com.zhihu.matisse.Matisse;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import id.zelory.compressor.Compressor;
import pub.devrel.easypermissions.EasyPermissions;

/**
 * Created by pc on 2018/5/5.
 */

public class SystemModule extends ReactContextBaseJavaModule {

    public static final String MODULE_NAME = "system";
    private ReactApplicationContext mContext;
    public SystemModule(ReactApplicationContext reactContext) {
        super(reactContext);
        this.mContext = reactContext;

    }

    @Override
    public String getName() {
        return MODULE_NAME;
    }


    /**
     *检查版本更新
     */
    @ReactMethod
    public void checkUpdate() {
        VersionParams.Builder builder = new VersionParams.Builder()
                .setRequestUrl(BuildConfig.APPLICATION_ID)
                .setService(XNVersionService.class);
        AllenChecker.startVersionCheck(mContext, builder.build());
    }

    //查询视频列表
    @ReactMethod
    public void queryVideoList(double maxSize, final Promise promise){

        VideoUtils videoUtils = new VideoUtils();
        videoUtils.queryVideoList(new VideoUtils.QueryResultListener() {
            @Override
            public void onSuccess(List<VideoBean> list) {
                if (list==null || list.size() == 0){
                    promise.resolve("");
                    return;
                }
                WritableNativeArray result = new WritableNativeArray();
                for(VideoBean videoBean : list) {
                    WritableMap imageDataMap = new WritableNativeMap();
                    imageDataMap.putString("filePath", videoBean.getFilePath());
                    imageDataMap.putDouble("duration", videoBean.getDuration());
                    imageDataMap.putDouble("size", videoBean.getSize());
                    imageDataMap.putString("dispalyName", videoBean.getDispalyName());
                    imageDataMap.putString("thumbnail", videoBean.getThumbnail());
                    imageDataMap.putInt("rotate",videoBean.getRotate());

                    result.pushMap(imageDataMap);
                }
                promise.resolve(result);

            }

            @Override
            public void onFailure(String message) {

                promise.resolve("");

            }
        },maxSize);

    }
    //获取定位信息
    @ReactMethod
    public void getLocation( final Promise promise){

        LocationCallBack service = new LocationCallBack() {
            @Override
            public void locationCallback(XnLocation xnLocation) {
                if(null == xnLocation){
                    promise.resolve("");
                } else {
                    promise.resolve(JSON.toJSONString(xnLocation));
                }

            }
        };
        //判断定位服务是否开启
        LocationManager lm = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
        boolean isGPSOK = lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
        boolean isNetWorkOK = lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
        if (RomCheck.isVivo()) {
            if (!isGPSOK && !isNetWorkOK) {
                showDialog(1, "在设置-定位服务中开始位置信息权限，以正常使用位置功能");
                promise.resolve("");
                return;
            }
            if (!isGPSOK && isNetWorkOK) {
                showDialog(0, "请开启手机的GPS定位功能，以正常使用位置功能");
                promise.resolve("");
                return;
            }
            XnDeviceApiUtils.getInstance().getLocation(service);
        } else {
            if (isGPSOK || isNetWorkOK) {
                if (getCurrentActivity() !=null && ContextCompat.checkSelfPermission(getCurrentActivity(), Manifest.permission.ACCESS_FINE_LOCATION)
                        != PackageManager.PERMISSION_GRANTED) {
                    showDialog(1, "在设置-应用-权限中开始位置信息权限，以正常使用位置功能");
                    promise.resolve("");
                } else {
                    XnDeviceApiUtils.getInstance().getLocation(service);
                }
            } else {
                showDialog(0, "在设置-定位服务中开始位置信息权限，以正常使用位置功能");
                promise.resolve("");
            }
        }
    }

    private void showDialog(int type, String str) {
        if (getCurrentActivity() == null) {
            return;
        }
        final AuthReqDialog dialog = new AuthReqDialog(getCurrentActivity());
        dialog.setTitle("权限申请");
        if (type == 0) {
            dialog.setCancelShow(true);
            dialog.setConfirmClickListener("去设置", new AuthReqDialog.OnConfirmClickListener() {
                @Override
                public void onConfirmClick() {
                    Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                    getCurrentActivity().startActivity(intent);
                    dialog.dismiss();
                }
            });
        } else {
            dialog.setCancelClickListener("取消", new AuthReqDialog.OnCancelClickListener() {
                @Override
                public void onCancelClick() {
                    dialog.dismiss();
                }
            });

            dialog.setConfirmClickListener("去设置", new AuthReqDialog.OnConfirmClickListener() {
                @Override
                public void onConfirmClick() {
                    Intent intent;
                    if (RomCheck.isVivo()) {
                        intent = new Intent(Settings.ACTION_SETTINGS);
                        getCurrentActivity().startActivity(intent);
                    } else {
                        intent = new Intent();
                        intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                        intent.setData(Uri.parse("package:" + getCurrentActivity().getPackageName()));
                        intent.addCategory(Intent.CATEGORY_DEFAULT);
                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                        intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
                        intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
                        getCurrentActivity().startActivity(intent);
                    }
                    dialog.dismiss();
                }
            });
        }
        dialog.setContent(str);
        dialog.show();
    }

    /**
     * 选择直辖市
     */
    @ReactMethod
    public  void cityChoose( String cityName,String cityList,final Promise promise){
        if (getCurrentActivity()==null){
            return;
        }
        Intent intent = new Intent(mContext, LocationChooseActivity.class);
        intent.putExtra("cityName",cityName);
        intent.putExtra("cityList",cityList);

        getCurrentActivity().startActivityForResult(intent, 100, null);
        mContext.addActivityEventListener(new ActivityEventListener() {
            @Override
            public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
                if (data != null) {
                    City city = (City) data.getSerializableExtra("city");
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("name",city.getName());
                    jsonObject.put("cityCode",city.getOrderIndex());
                    promise.resolve(JSON.toJSONString(jsonObject));
                }

                mContext.removeActivityEventListener(this);
            }

            @Override
            public void onNewIntent(Intent intent) {

            }
        });

    }

    /**
     * 芳疗师获取当前位置
     *
     * @param promise
     */
    @ReactMethod
    public void openMapView(final String longitude, final String latitude, final Promise promise) {

        if (getCurrentActivity() == null){
            return;
        }
        LocationService service = new LocationService() {
            @Override
            public void locationCallBack(LocationExtraBean bean) {
                promise.resolve(JSON.toJSONString(bean));
            }
        };
        //判断定位服务是否开启
        LocationManager lm = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
        boolean isGPSOK = lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
        boolean isNetWorkOK = lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
        if (RomCheck.isVivo()) {
            if (!isGPSOK && !isNetWorkOK) {
                showDialog(1, "在设置-定位服务中开始位置信息权限，以正常使用位置功能");
                return;
            }
            if (!isGPSOK && isNetWorkOK) {
                showDialog(0, "请开启手机的GPS定位功能，以正常使用位置功能");
                return;
            }
            LocationPickActivity.startNewTask(mContext,longitude,latitude, service);
        } else {
            if (isGPSOK || isNetWorkOK) {
                if (ContextCompat.checkSelfPermission(getCurrentActivity(), Manifest.permission.ACCESS_FINE_LOCATION)
                        != PackageManager.PERMISSION_GRANTED) {
                    showDialog(1, "在设置-应用-权限中开始位置信息权限，以正常使用位置功能");
                } else {
                    LocationPickActivity.startNewTask(mContext,longitude,latitude, service);
                }
            } else {
                showDialog(0, "在设置-定位服务中开始位置信息权限，以正常使用位置功能");
            }
        }

    }

    /**
     * 跳转至首页
     */
    @ReactMethod
    public void navTo(String page) {
        Activity currentActivity = getCurrentActivity();
        // 跳转到其它页面
        Intent intent = new Intent();
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); // 跳转需要添加flag, 否则报错
        if(page == null) {
            page = "";
        }
        ComponentName component = null;
        switch(page.toUpperCase()) {
            case "BACK":
                // 后退
                if (currentActivity == null){
                    return;
                }
                currentActivity.moveTaskToBack(true);
                break;
            case "FINISH":
                // 后退
                if(currentActivity != null) {
                    currentActivity.finish();
                }
                break;
            default:
                break;
        }

    }
    //图片浏览查看
    @ReactMethod
    public  void showPhotoWithUrl(String url,Promise promise){

        if (StringUtils.isEmpty(url)){
            return;
        }
        if (getCurrentActivity() ==null){
            return;
        }

        ArrayList<String> photos = new ArrayList<>();
        photos.add(url);

        Intent intent = new Intent(getCurrentActivity(), PhotoBrowserActivity.class);
        intent.putExtra(PhotoBrowserActivity.EXTRA_PHOTOS,photos);
        intent.putExtra(PhotoBrowserActivity.EXTRA_CURRENT_ITEM,0);
        getCurrentActivity().startActivity(intent);
    }
    /**
     * 选择图片
     * @param maxLength 最大张数
     * @param promise
     */
    @ReactMethod
    public void choosePic(int maxLength,final Promise promise){
        if (getCurrentActivity() == null){
            ToastUtils.showToast(mContext,"程序出问题了");
            return;
        }
        if (EasyPermissions.hasPermissions(mContext, Manifest.permission.CAMERA)) {
            PhotoPickerManager.toChoosePhotoOfImage(getCurrentActivity(),true,maxLength);

            mContext.addActivityEventListener(new ActivityEventListener() {
                @Override
                public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
                    if (data == null ){
                        promise.resolve("");
                        mContext.removeActivityEventListener(this);
                        return;
                    }
                    if (requestCode == PhotoPickerManager.PHOTO_PICKER_REQUEST){
                        //选择照片
                        List<String> pathList = Matisse.obtainPathResult(data);
                        if (pathList == null || pathList.size() ==0){
                            ToastUtils.showToast(getCurrentActivity(),"未获取到图片路径");
                            promise.resolve("");
                            mContext.removeActivityEventListener(this);
                            return;
                        }
                        WritableNativeArray result = new WritableNativeArray();
                        for(String path : pathList) {
                            // 压缩图片
                            try {
                                String  sdCardDir = Environment.getExternalStorageDirectory()+ "/compress/";
                                //目录转化成文件夹
                                File dirFile  = new File(sdCardDir);
                                //如果不存在，那就建立这个文件夹
                                if (!dirFile .exists()) {
                                    dirFile .mkdirs();
                                }
                                File file = new File(sdCardDir, "compress_00_"+System.currentTimeMillis()+".jpg");
                                File oriFile = new File(path);
                                Bitmap btFile = new Compressor(mContext).compressToBitmap(oriFile);
                                FileOutputStream fos = new FileOutputStream(file);
                                btFile.compress(Bitmap.CompressFormat.JPEG, 90, fos);
                                // 保存到map
                                WritableMap imageDataMap = new WritableNativeMap();
                                imageDataMap.putString("filePath", file.getPath());
                                result.pushMap(imageDataMap);
                            } catch (IOException e) {
                                e.printStackTrace();
                                continue;
                            }
                        }
                        promise.resolve(result);
                    }
                    mContext.removeActivityEventListener(this);
                }


                @Override
                public void onNewIntent(Intent intent) {

                }
            });

        } else {//申请权限
            EasyPermissions.requestPermissions(mContext, "需要开启相机权限才能正常使用哦~", 0, Manifest.permission.CAMERA);
        }


    }

    //打开会话消息
    @ReactMethod
    public void startP2PSessionFromRN(String conversationId,Promise promise){

    }
    /**
     *  简单上传
     *  上传文件第二步--上传到阿里云服务器
     * @param object
     * @param filePath
     */
    @ReactMethod
    public  void simpleUpload(String  keyId,
                              String secret,
                              String token,
                              String endpoint,
                              String mBucket,
                              String object,
                              String filePath,
                              final Promise promise){
        if (object.equals("")) {
            return;
        }
        java.io.File file = new java.io.File(filePath);
        if (!file.exists()) {
            // 如果不存在，可能传入的是Uri
            filePath = getRealFilePath(mContext,Uri.parse(filePath));
        }
        if(filePath == null){
            ToastUtils.showToast(mContext,"获取文件路径出错");
            return;
        }

        // 构造上传请求
        PutObjectRequest put = new PutObjectRequest(mBucket, object, filePath);
        put.setCRC64(OSSRequest.CRC64Config.YES);
        final OSS mOss = AliUploadFileService.initOSS(keyId,secret,token,endpoint);
        mOss.asyncPutObject(put, new OSSCompletedCallback<PutObjectRequest, PutObjectResult>() {
            @Override
            public void onSuccess(PutObjectRequest request, PutObjectResult result) {

                final  String url =   mOss.presignPublicObjectURL(request.getBucketName(), request.getObjectKey());
                promise.resolve(url);
            }

            @Override
            public void onFailure(PutObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
                // 请求异常
                if (clientExcepion != null) {//本地异常如网络异常等
                    ToastUtils.showToast(mContext,clientExcepion.toString());
                }
                if (serviceException != null) { // 服务异常
                    ToastUtils.showToast(mContext,serviceException.toString());
                }
            }
        });
    }

    /**
     *  简单上传--图片多张上传
     *  上传文件第二步--上传到阿里云服务器
     * @param object
     */

    //记录当前上传到第几张图片了
    int index = 0 ;
    @ReactMethod
    public  void batchUpload(String  keyId,
                             String secret,
                             String token,
                             ReadableArray infoList,
                             final ReadableArray filePathList,
                             final Promise promise){

        //记录上传成功的路径集合
        final List<String> uploadSuccessList = new ArrayList<>();
        for (int i = 0;i<infoList.size();i++){
            ReadableMap infoMap = infoList.getMap(i);
            ReadableMap filePathMap = filePathList.getMap(i);
            final OSS mOss = AliUploadFileService.initOSS(keyId,secret,token,infoMap.getString("endpoint"));
            String filePath = filePathMap.getString("filePath");
            java.io.File file = new java.io.File(filePath);
            if (!file.exists()) {
                //获取这张图片失败
                index++;
                resolveResult(index,filePathList.size(),uploadSuccessList,promise);
                return;
            }
            // 压缩图片
            // 构造上传请求
            String object  = infoMap.getString("fileUrl")==null?"":infoMap.getString("fileUrl");

            if (infoMap.getString("fileUrl").startsWith("/")){
                object =  infoMap.getString("fileUrl").substring(1);
            }
            PutObjectRequest put = new PutObjectRequest(infoMap.getString("bucket"), object, filePath);
            put.setCRC64(OSSRequest.CRC64Config.YES);
            mOss.asyncPutObject(put, new OSSCompletedCallback<PutObjectRequest, PutObjectResult>() {
                @Override
                public void onSuccess(PutObjectRequest request, PutObjectResult result) {

                    index++ ;
                    String url =   mOss.presignPublicObjectURL(request.getBucketName(), request.getObjectKey());
                    uploadSuccessList.add(url);
                    resolveResult(index,filePathList.size(),uploadSuccessList,promise);


                }

                @Override
                public void onFailure(PutObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
                    index++ ;
                    resolveResult(index,filePathList.size(),uploadSuccessList,promise);
                    //本地异常如网络异常等
                    if (clientExcepion != null) {
                        ToastUtils.showToast(mContext,clientExcepion.toString());
                    }
                    // 服务异常
                    if (serviceException != null) {
                        ToastUtils.showToast(mContext,serviceException.toString());
                    }
                }
            });
        }

    }
    //多张图片上传结果处理
    public void resolveResult(int indexImg,int totalCount,List<String>uploadSuccessList,Promise promise){
        //已经上传完毕
        if (indexImg == totalCount){
            //构造RN接收消息体类型
            WritableNativeArray resultArray = new WritableNativeArray();
            for(String path : uploadSuccessList) {
                resultArray.pushString(path);
            }
            index = 0;
            promise.resolve(resultArray);
        }
    }
    /**
     * 显示底部操作栏
     * @param promise
     */
    @ReactMethod
    public void showTabbar(Promise promise){

    }

    /**
     * 隐藏底部操作栏
     * @param promise
     */
    @ReactMethod
    public void hideTabbar(Promise promise){

    }

    @ReactMethod
    public void GotoSysSet(){

    }


    /**
     * 打开相册
     *
     * @param promise
     */
    @ReactMethod
    public void takePhotoWithpassportId(final String passportId, final Promise promise) {
        if (getCurrentActivity()==null){
            ToastUtils.showToast(MainApplication._this,"哇呜，程序出现了问题，请稍后重新尝试");
            return;
        }
        int from = PickImageActivity.FROM_CAMERA;
        final String get32UUID = StringUtil.get32UUID();
        String outputPath = StorageUtil.getWritePath(get32UUID + ".png", StorageType.TYPE_TEMP);
        PickImageActivity.start(getCurrentActivity(), 101, from,outputPath, false, 1,
                false, false, 0, 0);
        mContext.addActivityEventListener(new ActivityEventListener() {
            @Override
            public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
                if (data != null) {
                    String photoPath = data.getStringExtra(Extras.EXTRA_FILE_PATH);
                    if (TextUtils.isEmpty(photoPath)) {
                        //取消返回也会为null
                        Toast.makeText(getCurrentActivity(), R.string.picker_image_error, Toast.LENGTH_LONG).show();
                        promise.resolve("");
                        return;
                    }
                    // 压缩图片
                    try {
                        String  sdCardDir = Environment.getExternalStorageDirectory()+ "/compress/";
                        File dirFile  = new File(sdCardDir);
                        if (!dirFile .exists()) {
                            dirFile .mkdirs();
                        }
                        File file = new File(sdCardDir, "compress_00_"+System.currentTimeMillis()+".jpg");
                        File oriFile = new File(photoPath);
                        Bitmap btFile = new Compressor(mContext).compressToBitmap(oriFile);
                        FileOutputStream fos = new FileOutputStream(file);
                        btFile.compress(Bitmap.CompressFormat.JPEG, 90, fos);
                        // 保存到map
                        photoPath = file.getPath();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                    //阿里云上传
                    AliUploadFileService aliUploadFileService = new AliUploadFileService(getCurrentActivity(),true);
                    aliUploadFileService.setFileName(get32UUID + ".png");
                    aliUploadFileService.setListenerCallback(new ActionCallbackListener<String>() {
                        @Override
                        public void onSuccess(final String data) {
                            CameraDataBean cameraDataBean = new CameraDataBean();
                            cameraDataBean.setType("");
                            cameraDataBean.setUrl(data);

                            promise.resolve(JSON.toJSONString(cameraDataBean));
                        }

                        @Override
                        public void onFailure(String errorCode, String message) {
                            ToastUtils.showToast(getCurrentActivity(),message);
                            promise.resolve("");
                        }
                    });
                    aliUploadFileService.uploadFile(photoPath,passportId);

                }else {
                    promise.resolve("");
                }

                mContext.removeActivityEventListener(this);
            }

            @Override
            public void onNewIntent(Intent intent) {

            }
        });
    }



    /**
     *  rn 分享到微信好友
     * @param path  小程序页面路径
     * @param linkUrl  兼容低版本的网页链接
     * @param title  小程序消息title
     * @param description  小程序消息描述
     * @param thumbUrl  小程序消息封面图片
     * @param wxOriginalID 小程序 id
     */
    @ReactMethod
    public void wchatShare(String path,String linkUrl,String title,String description,String thumbUrl,String wxOriginalID){
//        if (getCurrentActivity() ==null){
//            return;
//        }
//        UMENGShareForRNUtil shareForRNUtil = new UMENGShareForRNUtil(getCurrentActivity());
//        shareForRNUtil.wchatShare(path,linkUrl,title,description,thumbUrl,wxOriginalID);
    }

    /**
     *  rn 分享到微信朋友圈
     * @param webUrl  消息的链接
     * @param title   消息的 title
     * @param description  消息的描述
     * @param thumbUrl  消息封面图片
     * @param wxOriginalID 小程序 id
     */
    @ReactMethod
    public void  wchatCircleShare(String webUrl,String title,String description,String thumbUrl,String wxOriginalID){
//        if (getCurrentActivity() ==null){
//            return;
//        }
//        UMENGShareForRNUtil shareForRNUtil = new UMENGShareForRNUtil(getCurrentActivity());
//        shareForRNUtil.wchatCircleShare(webUrl,title,description,thumbUrl);
    }



    /**
     * 拍照，带裁剪  takePhotoWithCropAndPassportId
     *
     * @param promise
     */
    @ReactMethod
    public void takePhotoWithCropAndPassportId(final String passportId, final Promise promise) {
        if (getCurrentActivity()==null){
            ToastUtils.showToast(MainApplication._this,"哇呜，程序出现了问题，请稍后重新尝试");
            return;
        }
        int from = PickImageActivity.FROM_CAMERA;
        final String get32UUID = StringUtil.get32UUID();
        String outputPath = StorageUtil.getWritePath(get32UUID + ".png", StorageType.TYPE_TEMP);
        PickImageActivity.start(getCurrentActivity(), 101, from,outputPath, false, 1,
                false, false, 0, 0);

        mContext.addActivityEventListener(new ActivityEventListener() {
            @Override
            public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
                if (data ==null || resultCode != -1 ){
                    promise.resolve("");
                    mContext.removeActivityEventListener(this);
                    return;
                }
                if (requestCode == 101){
                    //拍照返回
                    String photoPath = data.getStringExtra(Extras.EXTRA_FILE_PATH);
                    if (TextUtils.isEmpty(photoPath)) {
                        //取消返回也会为null
                        Toast.makeText(getCurrentActivity(), R.string.picker_image_error, Toast.LENGTH_LONG).show();
                        promise.resolve("");
                        mContext.removeActivityEventListener(this);
                        return;
                    }
                    // 压缩图片
                    try {
                        String  sdCardDir = Environment.getExternalStorageDirectory()+ "/compress/";
                        File dirFile  = new File(sdCardDir);
                        if (!dirFile .exists()) {
                            dirFile .mkdirs();
                        }
                        File file = new File(sdCardDir, "compress_00_"+System.currentTimeMillis()+".jpg");
                        File oriFile = new File(photoPath);
                        Bitmap btFile = new Compressor(mContext).compressToBitmap(oriFile);
                        FileOutputStream fos = new FileOutputStream(file);
                        btFile.compress(Bitmap.CompressFormat.JPEG, 90, fos);
                        // 保存到map
                        photoPath = file.getPath();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    startUCrop(photoPath);
                }
                if (requestCode == UCrop.REQUEST_CROP){
                    //裁剪返回
                    Uri resultUri = UCrop.getOutput(data);
                    if (resultUri !=null && resultUri.getPath() !=null){
                        final ActivityEventListener _this = this;
                        //阿里云上传
                        AliUploadFileService aliUploadFileService = new AliUploadFileService(getCurrentActivity(),true);
                        aliUploadFileService.setFileName(FileUtil.getFileName(resultUri.getPath()));
                        aliUploadFileService.setListenerCallback(new ActionCallbackListener<String>() {
                            @Override
                            public void onSuccess(final String data) {
                                CameraDataBean cameraDataBean = new CameraDataBean();
                                cameraDataBean.setType("");
                                cameraDataBean.setUrl(data);
                                promise.resolve(JSON.toJSONString(cameraDataBean));
                                mContext.removeActivityEventListener(_this);
                            }

                            @Override
                            public void onFailure(String errorCode, String message) {
                                ToastUtils.showToast(getCurrentActivity(),message);
                                mContext.removeActivityEventListener(_this);
                                promise.resolve("");
                            }
                        });
                        aliUploadFileService.uploadFile(resultUri.getPath(),passportId);
                    }else {
                        promise.resolve("");
                        mContext.removeActivityEventListener(this);
                        return;
                    }
                }
            }

            @Override
            public void onNewIntent(Intent intent) {

            }
        });
    }

    /**
     * 裁剪图片
     * @param sourcePath 图片原绝对路径
     * @return  文件名
     */
    public  String  startUCrop(String sourcePath){
        Uri sourceUri = Uri.fromFile(new File(sourcePath));
        String destinationPath = Environment.getExternalStorageDirectory() + "/" + MainApplication._this.getPackageName() + "/thumb";
        File outDir = new File(destinationPath);
        if (!outDir.exists()) {
            outDir.mkdirs();
        }
        String fileName = "crop_"+System.currentTimeMillis()+ ".jpg";
        Uri destinationUri = Uri.fromFile(new File(outDir,fileName));
        UCrop uCrop =  UCrop.of(sourceUri, destinationUri);
        //初始化UCrop配置
        UCrop.Options options = new UCrop.Options();
        //是否隐藏底部容器，默认显示
        options.setHideBottomControls(true);
        //设置toolbar颜色
        options.setToolbarColor(mContext.getResources().getColor(R.color.app_color));
        //设置状态栏颜色
        options.setStatusBarColor(mContext.getResources().getColor(R.color.app_color));
        //UCrop配置
        uCrop.withOptions(options);
        //设置裁剪图片的宽高比，比如16：9
        uCrop.withAspectRatio(1, 1);
        //跳转裁剪页面
        uCrop.start(getCurrentActivity(), UCrop.REQUEST_CROP);
        return  fileName;
    }
    public static String getRealFilePath( final Context context, final Uri uri ) {
        if ( null == uri ) {return null;}
        final String scheme = uri.getScheme();
        String data = null;
        if ( scheme == null ){
            data = uri.getPath();
        } else if ( ContentResolver.SCHEME_FILE.equals( scheme ) ) {
            data = uri.getPath();
        } else if ( ContentResolver.SCHEME_CONTENT.equals( scheme ) ) {
            Cursor cursor = context.getContentResolver().query( uri, new String[] { MediaStore.Images.ImageColumns.DATA }, null, null, null );
            if ( null != cursor ) {
                if ( cursor.moveToFirst() ) {
                    int index = cursor.getColumnIndex( MediaStore.Images.ImageColumns.DATA );
                    if ( index > -1 ) {
                        data = cursor.getString( index );
                    }
                }
                cursor.close();
            }
        }
        return data;
    }

}