基于NB-IoT的智慧路灯监控系统（NB-IoT专栏—实战篇5:手机应用开发）

public class NetConnectHeaderDataJSON {
   public static final String REQUEST_TYPE_GET = "GET";
   public static final String REQUEST_TYPE_POST = "POST";
   public static final String REQUEST_TYPE_PUT = "PUT";
   /**
    * 请求URL并返回内容
    * 
    * @param method
    *            方式get post
    * @param url
    *            地址
    * @param param
    *            参数
    * @return json
    */
   public static String request(Context context, String method, String url, String app_id, String token,
                                 List<NameValuePair> param) throws Exception {
      HttpResponse response;
      String result_https="";
      if (method.equals(REQUEST_TYPE_GET)){
         String ps ="";
         if (param != null) {
            List<NameValuePair> param2 = new ArrayList<NameValuePair>();
            for (int i = 0; i < param.size(); i++) {
               if (i>0) ps+="&";
               String key = param.get(i).getName();
               String value =param.get(i)
                     .getValue();
               ps+=key+"="+value;
            }
             ps = URLEncodedUtils.format(param2, HTTP.UTF_8);
            // 通过url创建对象
            if (url.indexOf("?") > 0) {
               url += "&" + ps;
            } else {
               url += "?" + ps;
            }
         }
         SSLSocketFactory ssl=DataManager.GETSSLinitHttpClientBook(context);

         HttpClient httpClient = new DefaultHttpClient();
         if (ssl != null) {
            Scheme sch = new Scheme("https", ssl, 443);
         httpClient.getConnectionManager().getSchemeRegistry().register(sch);
         }
         HttpGet request = new HttpGet(url);
         request.setHeader("app_key",app_id);
         request.setHeader("Authorization","Bearer "+token);
         request.setHeader("Content-Type","application/json");
//       request.setEntity(new UrlEncodedFormEntity(param));
         // 发起请求，获取回应，自封装接口，详见附录
          response = httpClient.execute(request);
         HttpEntity httpEntity = response.getEntity();
         // 得到一些数据
         // 通过EntityUtils并指定编码方式取到返回的数据
         StatusLine statusLine = response.getStatusLine();

         statusLine.getProtocolVersion();
         int statusCode = statusLine.getStatusCode();
         if (statusCode == 200) {
            result_https = (EntityUtils.toString(httpEntity, "utf-8"));
         }else{
            result_https=""+statusCode;
         }

      }else if(method.equals(REQUEST_TYPE_POST)){
         SSLSocketFactory ssl=DataManager.GETSSLinitHttpClientBook(context);

         HttpClient httpClient = new DefaultHttpClient();
         if (ssl != null) {
            Scheme sch = new Scheme("https", ssl, 443);
          httpClient.getConnectionManager().getSchemeRegistry().register(sch);
         }
         HttpPost request = new HttpPost(url);
         if (param != null) {
            String JsonData="";
            String startdata="{";
            String enddata="}";
            for (int i = 0; i < param.size(); i++) {
               String key = param.get(i).getName();
               String values = param.get(i).getValue();
//             param2.add(new BasicNameValuePair(key, values));
               if (i>0)
                  JsonData+=",";
               if (key.equals("timeout"))
                  JsonData+="\""+key+"\":"+values;
               else
                  JsonData+="\""+key+"\":\""+values+"\"";
            }
            //传入的是json格式的数据
            JsonData=startdata+JsonData+enddata;
            request.setEntity(new StringEntity(JsonData, HTTP.UTF_8));
         }
         request.setHeader("app_key",app_id);
         request.setHeader("Authorization","Bearer "+token);
         request.setHeader("Content-Type","application/json");
         response = httpClient.execute(request);
         HttpEntity httpEntity = response.getEntity();
         // 通过EntityUtils并指定编码方式取到返回的数据
         StatusLine statusLine = response.getStatusLine();
         int statusCode = statusLine.getStatusCode();
         if (statusCode == 200) {
            result_https = (EntityUtils.toString(httpEntity, "utf-8"));
         }else{
            result_https=""+statusCode;
         }
      }else if(method.equals(REQUEST_TYPE_PUT)){
         SSLSocketFactory ssl=DataManager.GETSSLinitHttpClientBook(context);
         HttpClient httpClient = new DefaultHttpClient();
         if (ssl != null) {
            Scheme sch = new Scheme("https", ssl, 443);
         httpClient.getConnectionManager().getSchemeRegistry().register(sch);
         }
         HttpPut request = new HttpPut(url);
         if (param != null) {
            String JsonData="";
            String startdata="{";
            String enddata="}";
            for (int i = 0; i < param.size(); i++) {
               String key = param.get(i).getName();
               String values = param.get(i).getValue();
               if (i>0)
                  JsonData+=",";
               if (key.equals("timeout"))
                  JsonData+="\""+key+"\":"+values;
               else
                  JsonData+="\""+key+"\":\""+values+"\"";
            }
            //传入的是json格式的数据
            JsonData=startdata+JsonData+enddata;
            request.setEntity(new StringEntity(JsonData, HTTP.UTF_8));
         }
         //
         request.setHeader("app_key",app_id);
         request.setHeader("Authorization","Bearer "+token);
         request.setHeader("Content-Type","application/json");
         response = httpClient.execute(request);
         HttpEntity httpEntity = response.getEntity();
         // 通过EntityUtils并指定编码方式取到返回的数据
         StatusLine statusLine = response.getStatusLine();
         int statusCode = statusLine.getStatusCode();
         if (statusCode == 204) {
            result_https = (EntityUtils.toString(httpEntity, "utf-8"));
         }else{
            result_https=""+statusCode;
         }
      }
      else{
         Log.i("method==", ".....");
      }
      return result_https;
   }
}

/**
 * 方法必须重写
 */
@Override
public void onResume() {
    super.onResume();
    mapView.onResume();
}
/**
 * 方法必须重写
 */
@Override
public void onPause() {
    super.onPause();
    mapView.onPause();
}
/**
 * 方法必须重写
 */
@Override
public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    mapView.onSaveInstanceState(outState);
}
/**
 * 方法必须重写
 */
@Override
public void onDestroy() {
    super.onDestroy();
    mapView.onDestroy();
    if (mTimerTask != null) {
        mTimerTask.cancel();
        mTimerTask = null;
    }
    try {
        mTimer.cancel();
    } catch (Throwable e) {
        e.printStackTrace();
    }
    deactivate();
}
@Override
public void onMapClick(LatLng latLng) {

}
@Override
public void onMapLoaded() {
    aMap.moveCamera(CameraUpdateFactory.zoomTo(zoomLevel));
}
@Override
public void activate(OnLocationChangedListener onLocationChangedListener) {
    mListener = onLocationChangedListener;
    startlocation();
}
@Override
public void deactivate() {
    mListener = null;
    if (mLocationClient != null) {
        mLocationClient.stopLocation();
        mLocationClient.onDestroy();
    }
    mLocationClient = null;
}
/**
 * 开始定位。
 */
private void startlocation() {

    if (mLocationClient == null) {
        mLocationClient = new AMapLocationClient(getActivity());
        mLocationOption = new AMapLocationClientOption();
        // 设置定位监听
        mLocationClient.setLocationListener(this);
        // 设置为高精度定位模式
  mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
        //设置为单次定位
        mLocationOption.setNeedAddress(true);
        mLocationOption.setOnceLocation(true);
        // 设置定位参数
        mLocationClient.setLocationOption(mLocationOption);
        mLocationClient.startLocation();
    } else {
        mLocationClient.startLocation();
    }
}
@Override
public void onLocationChanged(AMapLocation aMapLocation) {
    if (mListener != null && aMapLocation != null) {
        if (mTimerTask != null) {
            mTimerTask.cancel();
            mTimerTask = null;
        }
        if (aMapLocation != null && aMapLocation.getErrorCode() == 0) {
            LatLng mylocation = new LatLng(Absoult.Latitude, Absoult.Longitude);
            changeCamera(CameraUpdateFactory.newLatLngZoom(mylocation,zoomLevel),null);
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = new Date(aMapLocation.getTime());
            mTextViewCity.setText(aMapLocation.getCountry()+aMapLocation.getProvince()+aMapLocation.getCity());
            mTextViewAddress.setText(aMapLocation.getAddress());
            cityName = aMapLocation.getCity().substring(0,aMapLocation.getCity().length()-1);
            initWaetherData(cityName);
            aMapLocation.getAddress();//地址，如果option中设置isNeedAddress为false，则没有此结果，网络定位结果中会有地址信息，GPS定位不返回地址信息。
            aMapLocation.getCountry();//国家信息
            aMapLocation.getProvince();//省信息
            aMapLocation.getCity();//城市信息
            aMapLocation.getDistrict();//城区信息
            aMapLocation.getStreet();//街道信息
            aMapLocation.getStreetNum();//街道门牌号信息
            aMapLocation.getCityCode();//城市编码
            aMapLocation.getAdCode();//地区编码
            df.format(date);//定位时间
            if (locMarker==null){
                addLocationMarker(mylocation);
            }else {
                locMarker.setPosition(mylocation);
            }
            if (ac!=null){
                ac.setCenter(mylocation);
            }
            if (c!=null){
                c.setCenter(mylocation);
            }
            if (d!=null){
                d.setCenter(mylocation);
            }
        } else {
            String errText = "定位失败," + aMapLocation.getErrorCode() + ": "
                    + aMapLocation.getErrorInfo();
            Log.e("AmapErr", errText);
        }
    }
}
/**
 * 添加坐标点，这里可以添加任意坐标点位置
 * @param mylocation
 */
private void addLocationMarker(LatLng mylocation) {
    float accuracy = (float) ((mylocation.longitude/mylocation.latitude ));
    if (locMarker == null) {
        locMarker = addMarker(mylocation);
        if (ac==null){
            ac = aMap.addCircle(new CircleOptions().center(mylocation)
                    .fillColor(Color.argb(0, 98 ,189, 255)).radius(accuracy)
                    .strokeColor(Color.argb(0, 98, 198, 255)).strokeWidth(0));
        }
        if (c==null){
            c = aMap.addCircle(new CircleOptions().center(mylocation)
                    .fillColor(Color.argb(0, 98, 198, 255))
                    .radius(accuracy).strokeColor(Color.argb(0,98, 198, 255))
                    .strokeWidth(0));
        }
        if (d==null){
            d = aMap.addCircle(new CircleOptions().center(mylocation)
                    .fillColor(Color.argb(0, 98, 198, 255))
                    .radius(accuracy).strokeColor(Color.argb(0,98, 198, 255))
                    .strokeWidth(0));
        }
    } else {
        locMarker.setPosition(mylocation);
        ac.setCenter(mylocation);
        ac.setRadius(accuracy);
        c.setCenter(mylocation);
        c.setRadius(accuracy);
        d.setCenter(mylocation);
        d.setRadius(accuracy);
    }
    handle.postDelayed(rb,0);
    handle1.postDelayed(rb1,800);
    handle2.postDelayed(rb2,1600);
}
/**
 * 位置波纹扩散动画
 * @param ac
 */
private void Scalecircle1(final Circle ac) {
    ValueAnimator vm = ValueAnimator.ofFloat(0,(float)ac.getRadius());
    vm.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            float curent = (float) animation.getAnimatedValue();
            ac.setRadius(curent);
            aMap.invalidate();
        }
    });
    ValueAnimator vm1 = ValueAnimator.ofInt(160,0);
    vm1.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            int color = (int) animation.getAnimatedValue();
            ac.setFillColor(Color.argb(color, 98, 198, 255));
            aMap.invalidate();
        }
    });
    vm.setRepeatCount(Integer.MAX_VALUE);
    vm.setRepeatMode(ValueAnimator.RESTART);
    vm1.setRepeatCount(Integer.MAX_VALUE);
    vm1.setRepeatMode(ValueAnimator.RESTART);
    AnimatorSet set = new AnimatorSet();
    set.play(vm).with(vm1);
    set.setDuration(2500);
    set.setInterpolator(interpolator1);
    set.start();
}
private final Interpolator interpolator1 = new LinearInterpolator();
Runnable rb = new Runnable() {
    @Override
    public void run() {
        Scalecircle1(ac);
    }
};
Handler handle =new Handler();
Runnable rb1 = new Runnable() {
    @Override
    public void run() {
        Scalecircle1(c);
    }
};
Handler handle1 =new Handler();
Runnable rb2 = new Runnable() {
    @Override
    public void run() {
        Scalecircle1(d);
    }
};
Handler handle2 =new Handler();

public class ChartService {
   private GraphicalView mGraphicalView;
   private XYMultipleSeriesDataset multipleSeriesDataset;// 数据集容器
   private XYMultipleSeriesRenderer multipleSeriesRenderer;// 渲染器容器
   private XYSeries mSeries;// 单条曲线数据集
   private XYSeriesRenderer mRenderer;// 单条曲线渲染器
   private Context context;
   private Double xx ;
   int aa = 100;
   public ChartService(Context context) {
      this.context = context;
   }
   /**
    * 获取图表
    * 
    * @return
    */
   public GraphicalView getGraphicalView() {
      mGraphicalView = ChartFactory.getCubeLineChartView(context,
            multipleSeriesDataset, multipleSeriesRenderer, 0.1f);
      return mGraphicalView;
   }

   /**
    * 获取数据集，及xy坐标的集合
    * 
    * @param curveTitle
    */
   public void setXYMultipleSeriesDataset(String curveTitle) {
      multipleSeriesDataset = new XYMultipleSeriesDataset();
      mSeries = new XYSeries(curveTitle);
      multipleSeriesDataset.addSeries(mSeries);
   }
   /**
    * 获取渲染器
    * 
    * @param maxX
    *            x轴最大值
    * @param maxY
    *            y轴最大值
    * @param chartTitle
    *            曲线的标题
    * @param xTitle
    *            x轴标题
    * @param yTitle
    *            y轴标题
    * @param axeColor
    *            坐标轴颜色
    * @param labelColor
    *            标题颜色
    * @param curveColor
    *            曲线颜色
    * @param gridColor
    *            网格颜色
    */
   public void setXYMultipleSeriesRenderer(double maxX, double maxY,
         String chartTitle, String xTitle, String yTitle, int axeColor,
         int labelColor, int curveColor, int gridColor) {
      multipleSeriesRenderer = new XYMultipleSeriesRenderer();
      if (chartTitle != null) {
         multipleSeriesRenderer.setChartTitle(chartTitle);
      }
      multipleSeriesRenderer.setXTitle(xTitle);
      multipleSeriesRenderer.setYTitle(yTitle);
      multipleSeriesRenderer.setRange(new double[] { 0, maxX, 0, maxY });//xy轴的范围
      multipleSeriesRenderer.setLabelsColor(labelColor);
      multipleSeriesRenderer.setXLabels(5);
      multipleSeriesRenderer.setYLabels(10);
      multipleSeriesRenderer.setXLabelsAlign(Align.RIGHT);
      multipleSeriesRenderer.setYLabelsAlign(Align.RIGHT);
      multipleSeriesRenderer.setAxisTitleTextSize(35);
      multipleSeriesRenderer.setChartTitleTextSize(35);
      multipleSeriesRenderer.setLabelsTextSize(35);
      multipleSeriesRenderer.setLegendTextSize(35);
      multipleSeriesRenderer.setPointSize(5f);//曲线描点尺寸
      multipleSeriesRenderer.setFitLegend(true);
      multipleSeriesRenderer.setMargins(new int[] { 80, 80, 80, 80 });
      multipleSeriesRenderer.setShowGrid(true);
      multipleSeriesRenderer.setPanEnabled(false, false);//允许X轴可拉动
      multipleSeriesRenderer.setZoomEnabled(false, false);
      multipleSeriesRenderer.setAxesColor(axeColor);
      multipleSeriesRenderer.setGridColor(gridColor);
      multipleSeriesRenderer.setBackgroundColor(Color.WHITE);//背景色
      multipleSeriesRenderer.setMarginsColor(Color.WHITE);//边距背景色，默认背景色为黑色，这里修改为白色
      mRenderer = new XYSeriesRenderer();
      mRenderer.setLineWidth(3f);
      mRenderer.setColor(curveColor);
      mRenderer.setPointStrokeWidth(5f);
      mRenderer.setPointStyle(PointStyle.CIRCLE);//描点风格，可以为圆点，方形点等等
      multipleSeriesRenderer.addSeriesRenderer(mRenderer);
   }

   /**
    * 根据新加的数据，更新曲线，只能运行在主线程
    * 
    * @param x
    *            新加点的x坐标
    * @param y
    *            新加点的y坐标
    */
   public void updateChart(double x, double y) {
      mSeries.add(x, y);
      if (x>aa) {
         aa += 1;
         multipleSeriesRenderer.setXAxisMax(aa);// 设置X最大值
         multipleSeriesRenderer.setXAxisMin(aa - 100);// 设置X最小值
      }
      mGraphicalView.repaint();//此处也可以调用invalidate()
   }
   /**
    * 添加新的数据，多组，更新曲线，只能运行在主线程
    * @param xList
    * @param yList
    */
   public void updateChart(List<Double> xList, List<Double> yList) {
      for (int i = 0; i < xList.size(); i++) {
         xx = xList.get(i);
         mSeries.add(xx, yList.get(i));
      }
      mGraphicalView.repaint();//此处也可以调用invalidate()
   }
}

public abstract class NCalendar extends FrameLayout implements NestedScrollingParent, OnCalendarStateChangedListener, OnDateChangedListener, OnMonthAnimatorListener {
    protected WeekCalendar weekCalendar;
    protected MonthCalendar monthCalendar;
    protected int weekHeight;//周日历的高度
    protected int monthHeight;//月日历的高度,是日历整个的高
    protected int childLayoutLayoutTop;//onLayout中，定位的高度，
    protected int STATE;//默认月
    private int lastSate;//防止状态监听重复回调
    private OnCalendarChangedListener onCalendarChangedListener;
    //NCalendar内部包含的直接子view，直接子view并不一定是NestScrillChild
    protected ChildLayout childLayout;    protected Rect monthRect;//月日历大小的矩形
    protected Rect weekRect;//周日历大小的矩形 ，用于判断点击事件是否在日历的范
    private boolean isWeekHold;//是否需要周状态定住
    public NCalendar(@NonNull Context context) {
        this(context, null);
    }

    public NCalendar(@NonNull Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }
    public NCalendar(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        setMotionEventSplittingEnabled(false);
        Attrs attrss = AttrsUtil.getAttrs(context, attrs);
        int duration = attrss.duration;
        monthHeight = attrss.monthCalendarHeight;
        STATE = attrss.defaultCalendar;
        weekHeight = monthHeight / 5;
        isWeekHold = attrss.isWeekHold;
        weekCalendar = new WeekCalendar(context, attrss);
        monthCalendar = new MonthCalendar(context, attrss, duration, this);
        childLayout = new ChildLayout(getContext(), attrs, monthHeight, duration, this);
        monthCalendar.setOnDateChangedListener(this);
        weekCalendar.setOnDateChangedListener(this);
        childLayout.setBackgroundColor(attrss.bgChildColor);
        setCalenadrState(STATE);
        childLayoutLayoutTop = STATE == Attrs.WEEK ? weekHeight : monthHeight;
        post(new Runnable() {
            @Override
            public void run() {

                monthRect = new Rect(0, 0, monthCalendar.getWidth(), monthCalendar.getHeight());
                weekRect = new Rect(0, 0, weekCalendar.getWidth(), weekCalendar.getHeight());

                monthCalendar.setY(STATE == Attrs.MONTH ? 0 : getMonthYOnWeekState());
                childLayout.setY(STATE == Attrs.MONTH ? monthHeight : weekHeight);
            }
        });
    }

    /**
     * 根据ChildLayout的自动滑动结束的状态来设置月周日历的状态
     * 依据ChildLayout的状态来设置日历的状态
     *
     * @param isMonthState
     */
    @Override
    public void onCalendarStateChanged(boolean isMonthState) {
        if (isMonthState) {
            setCalenadrState(Attrs.MONTH);
        } else {
            setCalenadrState(Attrs.WEEK);
        }
    }

    /**
     * xml文件加载结束，添加月，周日历和child到NCalendar中
     */
    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();

        if (getChildCount() != 1) {
            throw new RuntimeException("NCalendar中的只能有一个直接子view");
        }
        childLayout.addView(getChildAt(0), new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));

        addView(monthCalendar, new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, monthHeight));
        addView(weekCalendar, new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, weekHeight));
        addView(childLayout, new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
    }
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        ViewGroup.LayoutParams childLayoutLayoutParams = childLayout.getLayoutParams();
        childLayoutLayoutParams.height = getMeasuredHeight() - weekHeight;

        //需要再调一次父类的方法？真机不调用首次高度不对，为何？
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        //super.onLayout(changed, l, t, r, b); //调用父类的该方法会造成 快速滑动月日历同时快速上滑recyclerview造成月日历的残影

        int measuredWidth = getMeasuredWidth();
        weekCalendar.layout(0, 0, measuredWidth, weekHeight);
        monthCalendar.layout(0, 0, measuredWidth, monthHeight);
        childLayout.layout(0, childLayoutLayoutTop, measuredWidth, childLayout.getMeasuredHeight() + childLayoutLayoutTop);
    }
    /**
     * 根据条件设置日历的月周状态，并回调状态变化
     *
     * @param state
     */
    private void setCalenadrState(int state) {

        if (state == Attrs.WEEK) {
            STATE = Attrs.WEEK;
            weekCalendar.setVisibility(VISIBLE);
        } else {
            STATE = Attrs.MONTH;
            weekCalendar.setVisibility(INVISIBLE);
        }

        if (onCalendarChangedListener != null && lastSate != state) {
            onCalendarChangedListener.onCalendarStateChanged(STATE == Attrs.MONTH);
        }

        lastSate = state;
    }
    /**
     * 自动滑动到适当的位置
     */
    private void autoScroll() {
        float childLayoutY = childLayout.getY();
        if (STATE == Attrs.MONTH && monthHeight - childLayoutY < weekHeight) {
            onAutoToMonthState();
        } else if (STATE == Attrs.MONTH && monthHeight - childLayoutY >= weekHeight) {
            onAutoToWeekState();
        } else if (STATE == Attrs.WEEK && childLayoutY < weekHeight * 2) {
            onAutoToWeekState();
        } else if (STATE == Attrs.WEEK && childLayoutY >= weekHeight * 2) {
            onAutoToMonthState();
        }
    }
    /**
     * 月日历和周日历的日期变化回调，每次日期变化都会回调，用于不同状态下，设置另一个日历的日期
     *
     * @param baseCalendar 日历本身
     * @param localDate    当前选中的时间
     * @param isDraw       是否绘制 此处选择都绘制，默认不选中，不适用鱼月周切换
     */
    @Override
    public void onDateChanged(BaseCalendar baseCalendar, LocalDate localDate, boolean isDraw) {
        if (baseCalendar instanceof MonthCalendar && STATE == Attrs.MONTH) {
            //月日历变化,改变周的选中
            weekCalendar.jumpDate(localDate, true);
            if (onCalendarChangedListener != null) {
                onCalendarChangedListener.onCalendarDateChanged(Util.getNDate(localDate));
            }
        } else if (baseCalendar instanceof WeekCalendar && STATE == Attrs.WEEK) {
            //周日历变化，改变月的选中
            monthCalendar.jumpDate(localDate, true);
            post(new Runnable() {
                @Override
                public void run() {
                    //此时需要根据月日历的选中日期调整Y值
                    // post是因为在前面得到当前view是再post中完成，如果不这样直接获取位置信息，会出现老的数据，不能获取正确的数据
                    monthCalendar.setY(getMonthYOnWeekState());
                }
            });
            if (onCalendarChangedListener != null) {
                onCalendarChangedListener.onCalendarDateChanged(Util.getNDate(localDate));
            }
        }
    }
    @Override
    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
        return true;
    }
    @Override
    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
        //跟随手势滑动
        gestureMove(dy, consumed);
    }
    @Override
    public boolean onNestedPreFling(View target, float velocityX, float velocityY) {
        //只有都在都在周状态下，才允许子View Fling滑动
        return !(childLayout.isWeekState() && monthCalendar.isWeekState());
    }
    @Override
    public void onStopNestedScroll(View target) {
        //该方法手指抬起的时候回调，此时根据此刻的位置，自动滑动到相应的状态，
        //如果已经在对应的位置上，则不执行动画，
        if (monthCalendar.isMonthState() && childLayout.isMonthState() && STATE == Attrs.WEEK) {
            setCalenadrState(Attrs.MONTH);
        } else if (monthCalendar.isWeekState() && childLayout.isWeekState() && STATE == Attrs.MONTH) {
            setCalenadrState(Attrs.WEEK);
        } else if (!childLayout.isMonthState() && !childLayout.isWeekState()) {
            //不是周状态也不是月状态时，自动滑动
            autoScroll();
        }
    }
    /**
     * 手势滑动的逻辑，做了简单处理，2种状态，都以ChildLayout滑动的状态判断
     * 1、向上滑动未到周状态
     * 2、向下滑动未到月状态
     *
     * @param dy
     * @param consumed
     */
    protected void gestureMove(int dy, int[] consumed) {
        float monthCalendarY = monthCalendar.getY();
        float childLayoutY = childLayout.getY();
        if (dy > 0 && !childLayout.isWeekState()) {
            monthCalendar.setY(-getGestureMonthUpOffset(dy) + monthCalendarY);
            childLayout.setY(-getGestureChildUpOffset(dy) + childLayoutY);
            if (consumed != null) consumed[1] = dy;
        } else if (dy < 0 && isWeekHold && childLayout.isWeekState()) {
            //不操作，
        } else if 
(dy < 0 && !childLayout.isMonthState() && !childLayout.canScrollVertically(-1)) {
            monthCalendar.setY(getGestureMonthDownOffset(dy) + monthCalendarY);
            childLayout.setY(getGestureChildDownOffset(dy) + childLayoutY);
            if (consumed != null) consumed[1] = dy;
        }

        onSetWeekVisible(dy);
    }
    /**
     * 月日历执行自动滑动动画的回调
     * 用来控制周日历的显示还是隐藏
     *
     * @param offset
     */
    @Override
    public void onMonthAnimatorChanged(int offset) {
        onSetWeekVisible(offset);
    }
    private int dowmY;
    private int downX;
    private int lastY;//上次的y
    private int verticalY = 50;//竖直方向上滑动的临界值，大于这个值认为是竖直滑动
    private boolean isFirstScroll = true; //第一次手势滑动，因为第一次滑动的偏移量大于verticalY，会出现猛的一划，这里只对第一次滑动做处理
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                dowmY = (int) ev.getY();
                downX = (int) ev.getX();
                lastY = dowmY;
                break;
            case MotionEvent.ACTION_MOVE:
                int y = (int) ev.getY();
                int absY = Math.abs(dowmY - y);
                boolean inCalendar = isInCalendar(downX, dowmY);
                if (absY > verticalY && inCalendar) {
                    //onInterceptTouchEvent返回true，触摸事件交给当前的onTouchEvent处理
                    return true;
                }
                break;
        }
        return super.onInterceptTouchEvent(ev);
    }
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_MOVE:
                int y = (int) event.getY();
                int dy = lastY - y;
                if (isFirstScroll) {
                    // 防止第一次的偏移量过大
                    if (dy > verticalY) {
                        dy = dy - verticalY;
                    } else if (dy < -verticalY) {
                        dy = dy + verticalY;
                    }
                    isFirstScroll = false;
                }
                // 跟随手势滑动
                gestureMove(dy, null);
                lastY = y;
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                isFirstScroll = true;
                autoScroll();
                break;
        }
        return true;
    }
    /**
     * 点击事件是否在日历的范围内
     *
     * @param x
     * @param y
     * @return
     */
    private boolean isInCalendar(int x, int y) {
        if (STATE == Attrs.MONTH) {
            return monthRect.contains(x, y);
        } else {
            return weekRect.contains(x, y);
        }
    }
    /**
     * 滑动过界处理 ，如果大于最大距离就返回最大距离
     *
     * @param offset    当前滑动的距离
     * @param maxOffset 当前滑动的最大距离
     * @return
     */
    protected float getOffset(float offset, float maxOffset) {
        if (offset > maxOffset) {
            return maxOffset;
        }
        return offset;
    }
    /**
     * 自动回到月的状态 包括月日历和chilayout
     */
    protected abstract void onAutoToMonthState();
    /**
     * 自动回到周的状态 包括月日历和chilayout
     */
    protected abstract void onAutoToWeekState();

    /**
     * 设置weekCalendar的显示隐藏，该方法会在手势滑动和自动滑动的的时候一直回调
     */
    protected abstract void onSetWeekVisible(int dy);
    /**
     * 周状态下 月日历的getY 是个负值
     * 用于在 周状态下日期改变设置正确的y值
     *
     * @return
     */
    protected abstract float getMonthYOnWeekState();
    /**
     * 月日历根据手势向上移动的距离
     *
     * @param dy 当前滑动的距离 dy>0向上滑动，dy<0向下滑动
     * @return 根据不同日历的交互，计算不同的滑动值
     */
    protected abstract float getGestureMonthUpOffset(int dy);
    /**
     * Child根据手势向上移动的距离
     *
     * @param dy 当前滑动的距离 dy>0向上滑动，dy<0向下滑动
     * @return 根据不同日历的交互，计算不同的滑动值
     */
    protected abstract float getGestureChildUpOffset(int dy);
    /**
     * 月日历根据手势向下移动的距离
     *
     * @param dy 当前滑动的距离 dy>0向上滑动，dy<0向下滑动
     * @return 根据不同日历的交互，计算不同的滑动值
     */
    protected abstract float getGestureMonthDownOffset(int dy);
    /**
     * Child根据手势向下移动的距离
     *
     * @param dy 当前滑动的距离 dy>0向上滑动，dy<0向下滑动
     * @return 根据不同日历的交互，计算不同的滑动值
     */
    protected abstract float getGestureChildDownOffset(int dy);
    /**
     * 跳转日期
     *
     * @param formatDate
     */
    public void jumpDate( String formatDate) {
        if (STATE == Attrs.MONTH) {
            monthCalendar.jumpDate(formatDate);
        } else {
            weekCalendar.jumpDate(formatDate);
        }
    }
    /**
     * 日历初始化的日期
     * @param formatDate
     */
    public void setInitializeDate(String formatDate) {
        monthCalendar.setInitializeDate(formatDate);
        weekCalendar.setInitializeDate(formatDate);
    }
    /**
     * 回到今天
     */
    public void toToday() {
        if (STATE == Attrs.MONTH) {
            monthCalendar.toToday();
        } else {
            weekCalendar.toToday();
        }
    }
    /**
     * 自动滑动到周视图
     */
    public void toWeek() {
        if (STATE == Attrs.MONTH) {
            onAutoToWeekState();
        }
    }
    /**
     * 自动滑动到月视图
     */
    public void toMonth() {
        if (STATE == Attrs.WEEK) {
            onAutoToMonthState();
        }
    }
    /**
     * 设置小圆点
     *
     * @param pointList
     */
    public void setPointList(List<String> pointList) {
        weekCalendar.setPointList(pointList);
        monthCalendar.setPointList(pointList);
    }
    /**
     * 获取当前日历的状态
     * Attrs.MONTH==月视图    Attrs.WEEK==周视图
     *
     * @return
     */
    public int getState() {
        return STATE;
    }
    /**
     * 下一页
     */
    public void toNextPager() {
        if (STATE == Attrs.MONTH) {
            monthCalendar.toNextPager();
        } else {
            weekCalendar.toNextPager();
        }
    }
    /**
     * 上一页
     */
    public void toLastPager() {
        if (STATE == Attrs.MONTH) {
            monthCalendar.toLastPager();
        } else {
            weekCalendar.toLastPager();
        }
    }
    /**
     * 设置日期区间
     *
     * @param startFormatDate
     * @param endFormatDate
     */
    public void setDateInterval(String startFormatDate, String endFormatDate) {
        monthCalendar.setDateInterval(startFormatDate, endFormatDate);
        weekCalendar.setDateInterval(startFormatDate, endFormatDate);
    }
    /**
     * 日期、状态回调
     *
     * @param onCalendarChangedListener
     */
    public void setOnCalendarChangedListener(OnCalendarChangedListener onCalendarChangedListener) {
        this.onCalendarChangedListener = onCalendarChangedListener;
    }
    /**
     * 点击不可用的日期回调
     *
     * @param onClickDisableDateListener
     */
    public void setOnClickDisableDateListener(OnClickDisableDateListener onClickDisableDateListener) {
        monthCalendar.setOnClickDisableDateListener(onClickDisableDateListener);
        weekCalendar.setOnClickDisableDateListener(onClickDisableDateListener);
    }
}