android 权限问题

6.0 Android引入动态权限，如果sdk指定targetSdkVersion > 23 那你应用运行使用的权限静态写入的就不够用了。要动态申请 否则就要报错，
一般用的权限有，sd卡读写（相册）、相机、音频、蓝牙、位置、拨号等等。
注意：一般相册只用的读的权限，如果只申请了读的权限，那么写的时候会出错，但是你查看权限的时候显示的是读写权限已被允许，以免造成干扰，所以最好是sd卡相关权限就一起申请

 ActivityCompat.requestPermissions(activity,
                    new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE},
                    REQUEST_CODE_ASK_STORAGE_PERMISSIONS);

权限申请栗子：

package com.ihealth.chronos.patient.control.permission;

import android.Manifest;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.AppOpsManager;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.Fragment;
import android.support.v4.content.ContextCompat;
import com.afollestad.materialdialogs.DialogAction;
import com.afollestad.materialdialogs.MaterialDialog;
import com.ihealth.chronos.patient.R;
import com.ihealth.chronos.patient.common.BasicActivity;
import com.ihealth.chronos.patient.util.LogUtil;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/**
* Created by huo on 2016/7/6.
* 权限管理
*/
public class PermissionManager {

   public static final int REQUEST_CODE_ASK_CAMERA_PERMISSIONS = 101;//申请相机
   public static final int REQUEST_CODE_ASK_STORAGE_PERMISSIONS = 102;//申请存储
   public static final int REQUEST_CODE_ASK_AUDIO_PERMISSIONS = 103;//申请音频
   public static final int REQUEST_CODE_ASK_AUDIO_MEASURE_PERMISSIONS = 104;//申请测量音频
   public static final int REQUEST_CODE_ASK_PHONE_PERMISSIONS = 105;//申请电话
   public static final int REQUEST_CODE_ASK_BlUETOOTH_PERMISSIONS = 106;//申请蓝牙
   public static final String SETTINGS_ACTION =
           "android.settings.APPLICATION_DETAILS_SETTINGS";
   public static final int WHAT_PER_MESSAGE = 0;//问医申请语音权限
   public static int what = -1;//标识检测权限的动作

   /***
    * 检测相册
    */
   public static boolean checkPhotoAlbum(Activity activity) {
       return checkPhotoAlbum(activity,-1);
   }

   /***
    * 检测相册
    */
   public static boolean checkPhotoAlbum(Activity activity,int whatTemp) {
       what = whatTemp;
       if (Build.VERSION.SDK_INT < 23) {
           return true;
       }
       int hasReadStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.READ_EXTERNAL_STORAGE);
       int hasWriteStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.WRITE_EXTERNAL_STORAGE);
       LogUtil.v("Permission  PermissionManager checkPhotoAlbum hasWriteStoragePermission = ",hasWriteStoragePermission,"  hasReadStoragePermission = ",hasReadStoragePermission);
       if (hasReadStoragePermission != PackageManager.PERMISSION_GRANTED || hasWriteStoragePermission != PackageManager.PERMISSION_GRANTED) {
           ActivityCompat.requestPermissions(activity,
                   new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE},
                   REQUEST_CODE_ASK_STORAGE_PERMISSIONS);
           return false;
       }
       return true;
   }

   /***
    * 检测相册
    */
   public static boolean checkPhotoAlbum(Activity activity,Fragment fragment) {
       if (Build.VERSION.SDK_INT < 23) {
           return true;
       }
       int hasReadStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.READ_EXTERNAL_STORAGE);
       int hasWriteStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.WRITE_EXTERNAL_STORAGE);
       LogUtil.v("Permission  PermissionManager checkPhotoAlbum hasWriteStoragePermission = ",hasWriteStoragePermission,"  hasReadStoragePermission = ",hasReadStoragePermission);
       if (hasReadStoragePermission != PackageManager.PERMISSION_GRANTED || hasWriteStoragePermission != PackageManager.PERMISSION_GRANTED) {
           if (!fragment.shouldShowRequestPermissionRationale(
                   Manifest.permission.READ_EXTERNAL_STORAGE)) {
               fragment.requestPermissions(
                       new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE},
                       REQUEST_CODE_ASK_STORAGE_PERMISSIONS);
               return false;
           }
           fragment.requestPermissions(
                   new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE},
                   REQUEST_CODE_ASK_STORAGE_PERMISSIONS);
           return false;
       }
       return true;
   }


   /***
    * 检测相册
    */
   public static boolean checkPhone(Activity activity,int whatTemp) {
       what = whatTemp;
       if (Build.VERSION.SDK_INT < 23) {
           return true;
       }
       int hasStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.READ_PHONE_STATE);
       LogUtil.v("Permission  PermissionManager checkPhotoAlbum hasStoragePermission = ",hasStoragePermission,"  hasStoragePermission = ",hasStoragePermission);
       if (hasStoragePermission != PackageManager.PERMISSION_GRANTED) {
           ActivityCompat.requestPermissions(activity,
                   new String[]{Manifest.permission.READ_PHONE_STATE},
                   REQUEST_CODE_ASK_PHONE_PERMISSIONS);
           return false;
       }
       return true;
   }

   /***
    * 检测相机
    */
   public static boolean checkCamera(Activity activity) {
       return checkCamera(activity,-1);
   }

   /***
    * 检测相机
    */
   private static boolean checkCamera(Activity activity,int whatTemp) {
       what = whatTemp;
       if (Build.VERSION.SDK_INT < 23) {
           return true;
       }
       int hasCameraPermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.CAMERA);
       int hasReadStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.READ_EXTERNAL_STORAGE);
       int hasWriteStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.WRITE_EXTERNAL_STORAGE);
       LogUtil.v("Permission  PermissionManager checkCamera hasCameraPermission = ",hasCameraPermission,"  hasStoragePermission = ",hasReadStoragePermission,"  hasWriteStoragePermission = ",hasWriteStoragePermission);
       if (hasCameraPermission != PackageManager.PERMISSION_GRANTED || hasReadStoragePermission != PackageManager.PERMISSION_GRANTED || hasWriteStoragePermission != PackageManager.PERMISSION_GRANTED) {
           ActivityCompat.requestPermissions(activity,
                       new String[]{Manifest.permission.CAMERA,Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE},
                       REQUEST_CODE_ASK_CAMERA_PERMISSIONS);
           return false;
       }
       return true;
   }

   /***
    * 检测相机
    */
   public static boolean checkCameraOnly(Activity activity) {
       if (Build.VERSION.SDK_INT < 23) {
           return true;
       }
       int hasCameraPermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.CAMERA);
       LogUtil.v("Permission  PermissionManager checkCamera hasCameraPermission = ",hasCameraPermission);
       if(hasCameraPermission != PackageManager.PERMISSION_GRANTED){
           ActivityCompat.requestPermissions(activity,
                   new String[]{Manifest.permission.CAMERA},
                   REQUEST_CODE_ASK_CAMERA_PERMISSIONS);
           return false;
       }
       return true;
   }

   /***
    * 检测音频
    */
   public static boolean checkAudio(Activity activity) {
      return checkAudio(activity,-1);
   }

   /***
    * 检测音频
    */
   public static boolean checkAudio(Activity activity,int whatTemp) {
       what = whatTemp;
       if (Build.VERSION.SDK_INT < 23) {
           return true;
       }
       int hasAudioPermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.RECORD_AUDIO);
       int hasReadStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.READ_EXTERNAL_STORAGE);
       int hasWriteStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.WRITE_EXTERNAL_STORAGE);
       LogUtil.v("Permission  PermissionManager checkAudio hasAudioPermission = ",hasAudioPermission,"  hasWriteStoragePermission = ",hasWriteStoragePermission,"  hasReadStoragePermission = ",hasReadStoragePermission);
       if (hasAudioPermission != PackageManager.PERMISSION_GRANTED || hasReadStoragePermission != PackageManager.PERMISSION_GRANTED|| hasWriteStoragePermission != PackageManager.PERMISSION_GRANTED) {
           ActivityCompat.requestPermissions(activity,
                   new String[]{Manifest.permission.RECORD_AUDIO,Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE},
                   REQUEST_CODE_ASK_AUDIO_PERMISSIONS);
           return false;
       }
       return true;
   }

   /***
    * 检测血压蓝牙相关权限
    */
   public static boolean checkBluetoothMeasure(Activity activity) {
       if (Build.VERSION.SDK_INT < 23) {
           return true;
       }
       int hasReadStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.READ_EXTERNAL_STORAGE);
       int hasWriteStoragePermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.WRITE_EXTERNAL_STORAGE);
       int hasAudioPermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.RECORD_AUDIO);
       int hasLocationPermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.ACCESS_FINE_LOCATION);
       if (hasReadStoragePermission != PackageManager.PERMISSION_GRANTED || hasWriteStoragePermission != PackageManager.PERMISSION_GRANTED || hasAudioPermission != PackageManager.PERMISSION_GRANTED
               || hasLocationPermission != PackageManager.PERMISSION_GRANTED) {
               ActivityCompat.requestPermissions(activity,
                       new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.RECORD_AUDIO,Manifest.permission.ACCESS_FINE_LOCATION},
                       REQUEST_CODE_ASK_BlUETOOTH_PERMISSIONS);
           return false;
       }
       return true;
   }


   /***
    * 检测音频
    */
   public static boolean checkAudioMeasure(Activity activity) {
       if (Build.VERSION.SDK_INT < 23) {
           return true;
       }
       int hasAudioPermission = ContextCompat.checkSelfPermission(activity,
               Manifest.permission.RECORD_AUDIO);
       if (hasAudioPermission != PackageManager.PERMISSION_GRANTED ) {//|| hasStoragePermission != PackageManager.PERMISSION_GRANTED
           ActivityCompat.requestPermissions(activity,
                   new String[]{Manifest.permission.RECORD_AUDIO},//,Manifest.permission.READ_EXTERNAL_STORAGE
                   REQUEST_CODE_ASK_AUDIO_MEASURE_PERMISSIONS);
           return false;
       }
       return true;
   }

   /***
    * 是否允许权限
    * @param grantResults
    * @param activity
    * @return
    */
   public static boolean isPermitPermissions(@NonNull int[] grantResults, final Activity activity,int code) {
       for (int state : grantResults){
           if (state != PackageManager.PERMISSION_GRANTED){
               if (!activity.isFinishing()){
                   MaterialDialog.Builder builder = new MaterialDialog.Builder(activity).autoDismiss(false)
                           .negativeColorRes(R.color.predefine_color_assist_red)
                           .onNegative(new MaterialDialog.SingleButtonCallback() {
                               @Override
                               public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                                   dialog.dismiss();
                               }
                           }).title(R.string.txt_permission_require_title).content(getPermissionsPrompt(code))
                           .positiveColorRes(R.color.predefine_font_important)
                           .onPositive(new MaterialDialog.SingleButtonCallback() {
                               @Override
                               public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                                       dialog.dismiss();
                                   Intent intent = new Intent();
                                   intent.setAction(SETTINGS_ACTION);
                                   intent.setData(Uri.fromParts("package",activity.getPackageName(), null));
                                   activity.startActivity(intent);
                               }
                           }).negativeText(R.string.cancel).positiveText(R.string.txt_permission_go_set);
                   builder.show();
               }
               return false;
           }
       }
       return true;
   }

   /***
    * 是否允许权限
    * @param grantResults
    * @param activity
    * @return
    */
   public static boolean isPermitPermissionsAndForceFinish(@NonNull int[] grantResults, final Activity activity,int code) {
       for (int state : grantResults){
           if (state != PackageManager.PERMISSION_GRANTED){
               if (!activity.isFinishing()){
                   MaterialDialog.Builder builder = new MaterialDialog.Builder(activity).autoDismiss(false)
                           .negativeColorRes(R.color.predefine_color_assist_red)
                           .onNegative(new MaterialDialog.SingleButtonCallback() {
                               @Override
                               public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                                   activity.finish();
                                   dialog.dismiss();
                               }
                           }).title(R.string.txt_permission_require_title).content(getPermissionsPrompt(code))
                           .positiveColorRes(R.color.predefine_font_important)
                           .onPositive(new MaterialDialog.SingleButtonCallback() {
                               @Override
                               public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                                   dialog.dismiss();
                                   Intent intent = new Intent();
                                   intent.setAction(SETTINGS_ACTION);
                                   intent.setData(Uri.fromParts("package",activity.getPackageName(), null));
                                   activity.startActivity(intent);
                               }
                           }).negativeText(R.string.cancel).positiveText(R.string.txt_permission_go_set);
                   builder.show();
               }
               return false;
           }
       }
       return true;
   }

   /***
    * 是否允许权限
    * @param grantResults
    * @param activity
    * @return
    */
   public static boolean isPermitPermissionsAndForceFinishDouble(@NonNull int[] grantResults, final Activity activity,int code) {
       for (int state : grantResults){
           if (state != PackageManager.PERMISSION_GRANTED){
               if (!activity.isFinishing()){
                   MaterialDialog.Builder builder = new MaterialDialog.Builder(activity).autoDismiss(false)
                           .negativeColorRes(R.color.predefine_color_assist_red)
                           .onNegative(new MaterialDialog.SingleButtonCallback() {
                               @Override
                               public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                                   activity.finish();
                                   dialog.dismiss();
                               }
                           }).title(R.string.txt_permission_require_title).content(getPermissionsPrompt(code))
                           .positiveColorRes(R.color.predefine_font_important)
                           .onPositive(new MaterialDialog.SingleButtonCallback() {
                               @Override
                               public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                                   dialog.dismiss();
                                   activity.finish();
                                   Intent intent = new Intent();
                                   intent.setAction(SETTINGS_ACTION);
                                   intent.setData(Uri.fromParts("package",activity.getPackageName(), null));
                                   activity.startActivity(intent);
                               }
                           }).negativeText(R.string.cancel).positiveText(R.string.txt_permission_go_set);
                   builder.show();
               }
               return false;
           }
       }
       return true;
   }
   /***
    * 是否允许权限 点击取消不finish
    * @param grantResults
    * @param activity
    * @return
    */
   public static boolean isPermitPermissionsAndForceNoFinishDouble(@NonNull int[] grantResults, final Activity activity,int code) {
       for (int state : grantResults){
           if (state != PackageManager.PERMISSION_GRANTED){
               if (!activity.isFinishing()){
                   MaterialDialog.Builder builder = new MaterialDialog.Builder(activity).autoDismiss(false)
                           .negativeColorRes(R.color.predefine_color_assist_red)
                           .onNegative(new MaterialDialog.SingleButtonCallback() {
                               @Override
                               public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
//                                    activity.finish();
                                   dialog.dismiss();
                               }
                           }).title(R.string.txt_permission_require_title).content(getPermissionsPrompt(code))
                           .positiveColorRes(R.color.predefine_font_important)
                           .onPositive(new MaterialDialog.SingleButtonCallback() {
                               @Override
                               public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                                   dialog.dismiss();
//                                    activity.finish();
                                   Intent intent = new Intent();
                                   intent.setAction(SETTINGS_ACTION);
                                   intent.setData(Uri.fromParts("package",activity.getPackageName(), null));
                                   activity.startActivity(intent);
                               }
                           }).negativeText(R.string.cancel).positiveText(R.string.txt_permission_go_set);
                   builder.show();
               }
               return false;
           }
       }
       return true;
   }

   private static int getPermissionsPrompt(int code){
       switch (code){
           case REQUEST_CODE_ASK_CAMERA_PERMISSIONS:
               return R.string.txt_permission_require_camera;
           case REQUEST_CODE_ASK_STORAGE_PERMISSIONS:
               return R.string.txt_permission_require_storage;
           case REQUEST_CODE_ASK_AUDIO_PERMISSIONS:
           case REQUEST_CODE_ASK_AUDIO_MEASURE_PERMISSIONS:
               return R.string.txt_permission_require_audio;
           case REQUEST_CODE_ASK_PHONE_PERMISSIONS:
               return R.string.txt_permission_require_phone;
           case REQUEST_CODE_ASK_BlUETOOTH_PERMISSIONS:
               return R.string.txt_permission_require_bluetooth;
       }
       return 0;
   }

   private static final String CHECK_OP_NO_THROW = "checkOpNoThrow";
   private static final String OP_POST_NOTIFICATION = "OP_POST_NOTIFICATION";

   /**
    * 检测通知权限
    * @param context
    * @return
    */
   @SuppressLint("NewApi")
   public static boolean checkNotificationEnabled(final BasicActivity context) {
       boolean isEnabled;
       AppOpsManager mAppOps = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
       ApplicationInfo appInfo = context.getApplicationInfo();
       String pkg = context.getApplicationContext().getPackageName();
       int uid = appInfo.uid;

       Class appOpsClass = null;
     /* Context.APP_OPS_MANAGER */
       try {
           appOpsClass = Class.forName(AppOpsManager.class.getName());
           Method checkOpNoThrowMethod = appOpsClass.getMethod(CHECK_OP_NO_THROW, Integer.TYPE, Integer.TYPE,
                   String.class);
           Field opPostNotificationValue = appOpsClass.getDeclaredField(OP_POST_NOTIFICATION);
           int value = (Integer) opPostNotificationValue.get(Integer.class);
           isEnabled =  ((Integer) checkOpNoThrowMethod.invoke(mAppOps, value, uid, pkg) == AppOpsManager.MODE_ALLOWED);
       } catch (ClassNotFoundException | NoSuchMethodException | NoSuchFieldException | InvocationTargetException | IllegalAccessException e) {
           isEnabled = true;
           e.printStackTrace();
       }

       if (!isEnabled){
           MaterialDialog.Builder builder = new MaterialDialog.Builder(context).autoDismiss(false)
                   .negativeColorRes(R.color.predefine_color_assist_red)
                   .onNegative(new MaterialDialog.SingleButtonCallback() {
                       @Override
                       public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                           dialog.dismiss();
                           context.finish();
                       }
                   }).content(R.string.txt_permission_require_notification)
                   .positiveColorRes(R.color.predefine_font_important)
                   .onPositive(new MaterialDialog.SingleButtonCallback() {
                       @Override
                       public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                           dialog.dismiss();
                           Intent intent = new Intent();
                           intent.setAction(SETTINGS_ACTION);
                           intent.setData(Uri.fromParts("package",context.getPackageName(), null));
                           context.startActivity(intent);
                       }
                   }).negativeText(R.string.non).positiveText(R.string.open_notifi);
           builder.show();
       }
       return isEnabled;
   }

   /**
    * 检测通知权限
    * @param context
    * @return
    */
   @SuppressLint("NewApi")
   public static boolean checkMedicationNotificationEnabled(final BasicActivity context) {
       boolean isEnabled;
       AppOpsManager mAppOps = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
       ApplicationInfo appInfo = context.getApplicationInfo();
       String pkg = context.getApplicationContext().getPackageName();
       int uid = appInfo.uid;

       Class appOpsClass = null;
     /* Context.APP_OPS_MANAGER */
       try {
           appOpsClass = Class.forName(AppOpsManager.class.getName());
           Method checkOpNoThrowMethod = appOpsClass.getMethod(CHECK_OP_NO_THROW, Integer.TYPE, Integer.TYPE,
                   String.class);
           Field opPostNotificationValue = appOpsClass.getDeclaredField(OP_POST_NOTIFICATION);
           int value = (Integer) opPostNotificationValue.get(Integer.class);
           isEnabled =  ((Integer) checkOpNoThrowMethod.invoke(mAppOps, value, uid, pkg) == AppOpsManager.MODE_ALLOWED);
       } catch (ClassNotFoundException | NoSuchMethodException | NoSuchFieldException | InvocationTargetException | IllegalAccessException e) {
           isEnabled = true;
           e.printStackTrace();
       }
       return isEnabled;
   }
}

调用：相机相册

 if (PermissionManager.checkCamera(MyInfoActivity.this))
                            choosePhoto();

回调：相机相册

 @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode) {
            case PermissionManager.REQUEST_CODE_ASK_CAMERA_PERMISSIONS:
                if (PermissionManager.isPermitPermissions(grantResults,this,requestCode))
                    choosePhoto();
                break;
            case PermissionManager.REQUEST_CODE_ASK_STORAGE_PERMISSIONS:
                if (PermissionManager.isPermitPermissions(grantResults,this,requestCode))
                    handleSelectPicture();
                break;
            default:
                super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
    }
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,816评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,729评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 158,300评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,780评论 1赞 285
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,890评论 6赞 385
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,084评论 1赞 291
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,151评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,912评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,355评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,666评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,809评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,504评论 4赞 334
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,150评论 3赞 317
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,882评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,121评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,628评论 2赞 362
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,724评论 2赞 351