MKMapKit(七)：指南针追踪工具

Compass.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#import <UIKit/UIKit.h>
#import "MapKit.h"

@interface MapKit (Compass)

/**
 * 在MapKit的Tracking模式中的CameraHeading模式下计算self.camera.heading应该赋值多少
 * @param degrees LocationManager的Heading角度
 * @return
 */
+ (CLLocationDirection)cameraHeadingInCameraHeadingModeByDegrees:(CLLocationDegrees)degrees;

/**
 * 1. 在MapKit的Tracking模式中的TransformHeading模式下，应该如何转动MapKit的Transform保证其TransformIdentity始终指向正北方0度
 * 2. 用于在不同的Tracking模式下，View如果想锁定指向时的辅助函数
 * @param degrees LocationManager的Heading角度
 */
+ (CATransform3D)transformInTransformHeadingModeByDegrees:(CLLocationDegrees)degrees;

/**
 * 在不同的Tracking模式下，保证View始终指向锁定的角度
 * @param heading 锁定的角度 0 - 360，其中0为正北方
 * @param mapHeading 当前地图的角度，一般为LocationManage刷新的设备角度
 * @param mode 当前MapKit使用的追踪模式
 * @return
 */
+ (CATransform3D)keepHeadingDegrees:(CLLocationDirection)heading withLocationHeading:(CLLocationDirection)mapHeading inMode:(MapKitTrackingMode)mode;

/**
 * 在不开启Tracking的模式下()，在对MapKit进行了RotateGesture的情况下，UIView锁定指向
 * @param heading 锁定的角度 0 - 360
 * @param cameraHeading 当前MapKit的摄像头角度，self.camera.heading 在Rotate了地图之后该参数会变化
 * @return
 */
+ (CATransform3D)keepTrackingNoneModeHeadingDegrees:(CLLocationDegrees)heading withCameraHeading:(CLLocationDirection)cameraHeading;

@end

Compass.m

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

#import "MapKit+Compass.h"

/**
 *
 * 以 ！！！2014年旋转Transform的Map例子中  ！！！！分析
 *
 * 首先假设设备处于UIInterfaceOrientationPortrait
 * 指南针度数  偏转角度  +360度至递减
 *    135      -135       225
 *    225      135        135
 * 解方程
 * degrees = 360 - degrees;
 *
 * 在UIInterfaceOrientationLandscapeRight情况下
 * 指南针度数  偏转角度  +360度至递减
 *    0        -90       270
 *    45       -135      225
 *    90       -180      180
 *!!! 120      150       150
 *    135      135       135
 *    180      90        90
 *    225      45        45
 *    270      0         0
 *    315      -45       -45
 *    360      -90       -90
 *    使用二元一次方程组 y = ax+b
 *    观察数据可得
 *    偏转角度 = -指南针度数 + 270
 *    感谢 Ye.Tao-2 提供的计算能力
 *    解方程
 *    可得 degrees = 270-degrees;
 *    即 Portrait 向左倾倒，设备旋转了 -90度 360 - degrees -90
 *
 *
 *
 * 在UIInterfaceOrientationLandscapeLeft
 * 指南针度数  偏转角度  +360度至递减
 *    225      -135       225
 *    270      -180       180
 *    315      135        135
 * 解方程
 * 可得 degrees = 450-degrees;
 * 即 Portrait 向右倾倒，设备旋转了 -90度 360 - degrees -90
 *
 *
 *
 * 在 UIDeviceOrientationPortraitUpsideDown
 * 即 Portrait 向右倾倒旋转180度(360 - degrees + 180) ，或者向左倾倒旋转-180度(360 -degrees - 180)
 *
 *
 *
 */

@implementation MapKit (Compass)


+ (CLLocationDirection)cameraHeadingInCameraHeadingModeByDegrees:(CLLocationDegrees)degrees {
    CLLocationDirection temp = [self degreesRangeProcess:degrees];
    //首先假设设备处于UIInterfaceOrientationPortrait
    if(UIInterfaceOrientationIsLandscape([[UIApplication sharedApplication] statusBarOrientation])) {
        temp = 180  + temp;
    }
    //处理设备旋转
    temp = [self deviceOrientationProcess:temp];

    return temp;
}

+ (CATransform3D)transformInTransformHeadingModeByDegrees:(CLLocationDegrees)degrees {
    CLLocationDirection temp = [self degreesRangeProcess:degrees];
    //首先假设设备处于UIInterfaceOrientationPortrait
    temp = 360 - temp;
    //处理设备旋转
    temp = [self deviceOrientationProcess:temp];

    return CATransform3DMakeRotation([self degreesToRadians:temp], 0, 0, 1);
}

+ (CATransform3D)keepHeadingDegrees:(CLLocationDirection)heading withLocationHeading:(CLLocationDirection)mapHeading inMode:(MapKitTrackingMode)mode {
    switch (mode) {
        case MapKitTrackingModeFollowWithHeading:
            return [self keepFellowModeHeadingDegrees:heading withMapHeading:mapHeading];
        case MapKitTrackingModeCameraHeading:
            return [self keepCameraModeHeadingDegrees:heading withMapHeading:mapHeading];
        case MapKitTrackingModeTransformHeading:
            return CATransform3DMakeRotation([self degreesToRadians:heading], 0, 0, 1);
        default:
            break;
    }
    return CATransform3DIdentity;
}

+ (CATransform3D)keepTrackingNoneModeHeadingDegrees:(CLLocationDirection)heading withCameraHeading:(CLLocationDirection)cameraHeading {
    CLLocationDegrees temp = [self deviceOrientationProcess:cameraHeading];
    return [self keepCameraModeHeadingDegrees:heading withMapHeading:temp];

}

#pragma mark - Logic Funcation

+ (CATransform3D)keepFellowModeHeadingDegrees:(CLLocationDirection)heading withMapHeading:(CLLocationDirection)mapHeading {
    /**
     * 在MapKitTrackingModeFollowWithHeading模式下
     * heading度数x  CATransform3DIdentity指向地图角度 偏移量y
     *   0                   0                      360
     *   45                  -45                    315
     *   90                  -90                    270
     *   135                 -135                   225
     *   180                 180                    180
     *   225                 135                    135
     *   270                 90                     90
     *   315                 45                     45
     *   360                 0                      0
     */
    mapHeading = - heading + mapHeading;
    return [self transformInTransformHeadingModeByDegrees:mapHeading];
}

+ (CATransform3D)keepCameraModeHeadingDegrees:(CLLocationDirection)heading withMapHeading:(CLLocationDirection)mapHeading {
    /**
     * 在MapKitTrackingModeCameraHeading模式下
     * heading度数x  CATransform3DIdentity指向地图角度 偏移量y
     *   0                   0                      360
     *   45                  -45                    315
     *   90                  -90                    270
     *   135                 -135                   225
     *   180                 180                    180
     *   225                 135                    135
     *   270                 90                     90
     *   315                 45                     45
     *   360                 0                      0
     */
    mapHeading = -heading + mapHeading;
    return [self transformInTransformHeadingModeByDegrees:mapHeading];
}

#pragma mark - Associate Funcation

+ (CLLocationDegrees)degreesRangeProcess:(CLLocationDegrees)degrees {
    CLLocationDirection temp = degrees;
    while (temp > 360) {
        temp -= 360;
    }
    while (temp < 0) {
        temp += 360;
    }
    return temp;
}

+ (CLLocationDegrees)deviceOrientationProcess:(CLLocationDegrees)degrees {
    /**
     * 首先假设设备处于UIInterfaceOrientationPortrait
     */
    CLLocationDirection temp = degrees;
#if !TARGET_OS_SIMULATOR
    if ([[UIApplication sharedApplication] statusBarOrientation] == UIInterfaceOrientationLandscapeRight) {
        /**
         * 在UIInterfaceOrientationLandscapeRight情况下
         * 即 Portrait 向左倾倒，设备旋转了 -90度 degrees -90
         */
        temp = temp - 90;
    } else if ([[UIApplication sharedApplication] statusBarOrientation] == UIInterfaceOrientationLandscapeLeft) {
        /**
         * 在UIInterfaceOrientationLandscapeLeft
         * 即 Portrait 向右倾倒，设备旋转了 +90度 degrees +90
         */
        temp = temp + 90;
    } else if ([[UIApplication sharedApplication] statusBarOrientation] == UIDeviceOrientationPortraitUpsideDown) {
        /**
         * 在 UIDeviceOrientationPortraitUpsideDown
         * 即 Portrait 向右倾倒旋转180度(degrees + 180) ，或者向左倾倒旋转-180度(degrees - 180)
         */
        temp = temp + 180;
    }
#endif
    return temp;
}

+ (CGFloat)degreesToRadians:(CLLocationDegrees)degrees {
    return degrees*M_PI/180.0f;
}

@end

展开全文 >>

MKMapKit(六)：指南针模式

指南针模式是什么

我自己起的名字，所谓指南针模式，就是MKMapView的MKUserTrackingModeFollowWithHeading模式，只不过MKMapView只能够让用户点自身进入Tracking模式

而且在打开Tracking模式的时候，Apple会十分体贴的帮你Zoom到用户点

导致有些需求无法规避这个动画。

1
[mapView setUserTrackingMode:MKUserTrackingModeFollowWithHeading animated:animate];

实现自定义指南针模式的方法

如果想要模仿FollowWithHeading有两个方法，并且各有优劣，但是无论使用何种方法，都是通过LocationManage获取到设备的Heading值，然后根据Heading值对MapView进行设置

方法 实现 优点 缺点
Transform 根据Heading值改变MapView的Transform 简单，Overlay和Annotation始终保持TransformIdentity 需要大于ScreenView的MapView，标志物不会自动调整方向
Camera 根据Heading值改变MapView.Camera镜头状态 Overlay和Annotation以及字体会自动调整方向 Annotaiton如果需要保持Heading，需要更复杂的计算

Transform

通过设置地图的layer来达到Tracking旋转效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
- (void)locationManager:(CLLocationManager *)manager didUpdateHeading:(CLHeading *)newHeading {
  [self.layer setTransform:[MapKit transformInTransformHeadingModeByDegrees:heading]];
}

+ (CATransform3D)transformInTransformHeadingModeByDegrees:(CLLocationDegrees)degrees {
    CLLocationDirection temp = [self degreesRangeProcess:degrees];
    //首先假设设备处于UIInterfaceOrientationPortrait
    temp = 360 - temp;
    //处理设备旋转
    temp = [self deviceOrientationProcess:temp];

    return CATransform3DMakeRotation([self degreesToRadians:temp], 0, 0, 1);
}

需要配合函数 transformInTransformHeadingModeByDegrees 来计算旋转的Transform，由指南针追踪工具提供

Camera

通过设置地图的Camera来达到Tracking旋转效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
- (void)locationManager:(CLLocationManager *)manager didUpdateHeading:(CLHeading *)newHeading {
  [self.camera setHeading:[MapKit cameraHeadingInCameraHeadingModeByDegrees:heading]];
}

+ (CLLocationDirection)cameraHeadingInCameraHeadingModeByDegrees:(CLLocationDegrees)degrees {
    CLLocationDirection temp = [self degreesRangeProcess:degrees];
    //首先假设设备处于UIInterfaceOrientationPortrait
    if(UIInterfaceOrientationIsLandscape([[UIApplication sharedApplication] statusBarOrientation])) {
        temp = 180  + temp;
    }
    //处理设备旋转
    temp = [self deviceOrientationProcess:temp];

    return temp;
}

需要配合函数 cameraHeadingInCameraHeadingModeByDegrees 来计算旋转的Heading，由指南针追踪工具提供

公用预处理函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
+ (CLLocationDegrees)degreesRangeProcess:(CLLocationDegrees)degrees {
    CLLocationDirection temp = degrees;
    while (temp > 360) {
        temp -= 360;
    }
    while (temp < 0) {
        temp += 360;
    }
    return temp;
}

+ (CLLocationDegrees)deviceOrientationProcess:(CLLocationDegrees)degrees {
    /**
     * 首先假设设备处于UIInterfaceOrientationPortrait
     */
    CLLocationDirection temp = degrees;
#if !TARGET_OS_SIMULATOR
    if ([[UIApplication sharedApplication] statusBarOrientation] == UIInterfaceOrientationLandscapeRight) {
        /**
         * 在UIInterfaceOrientationLandscapeRight情况下
         * 即 Portrait 向左倾倒，设备旋转了 -90度 degrees -90
         */
        temp = temp - 90;
    } else if ([[UIApplication sharedApplication] statusBarOrientation] == UIInterfaceOrientationLandscapeLeft) {
        /**
         * 在UIInterfaceOrientationLandscapeLeft
         * 即 Portrait 向右倾倒，设备旋转了 +90度 degrees +90
         */
        temp = temp + 90;
    } else if ([[UIApplication sharedApplication] statusBarOrientation] == UIDeviceOrientationPortraitUpsideDown) {
        /**
         * 在 UIDeviceOrientationPortraitUpsideDown
         * 即 Portrait 向右倾倒旋转180度(degrees + 180) ，或者向左倾倒旋转-180度(degrees - 180)
         */
        temp = temp + 180;
    }
#endif
    return temp;
}

+ (CGFloat)degreesToRadians:(CLLocationDegrees)degrees {
    return degrees*M_PI/180.0f;
}

指南针模式下Annotation锁定朝向

在不同的指南针模式下，我们始终想让某一个标志物锁定朝向，不会随着 设备的旋转导致的地图旋转而产生偏向 可以使用由指南针追踪工具提供的函数来设置Transform

展开全文 >>

MKMapKit(五)：调用自带地图导航

调用苹果地图导航

调用苹果自带地图导航的相关类叫 MapItem,导航的英文不叫Navigation而是叫Direction，相关官方文档为Asking the Maps App to Display Directions

MapItem

调用方法

MapItem一共有两个方法

方法名 作用
+ openMapsWithItems:launchOptions: 跳转到自带地图并且打开一组Item
- openInMapsWithLaunchOptions: 跳转到自带地图，打开这个Item

Options

可以看到两个方法都提到了Options，具体的Options包括以下

| Option | 取值 | 可选项 |
| :————- | :————- |
| MKLaunchOptionsDirectionsModeKey | 导航方式，有四个选项，比如步行还是开车官方文档 | MKLaunchOptionsDirectionsModeDriving,MKLaunchOptionsDirectionsModeWalking,MKLaunchOptionsDirectionsModeTransit,MKLaunchOptionsDirectionsModeDefault |
| MKLaunchOptionsMapTypeKey | 地图模式，采用NSNumber | 对应MKMapType的枚举 |
| MKLaunchOptionsMapCenterKey | NSValue | 把Coordinate编码成NSValue |
| MKLaunchOptionsMapSpanKey | NSValue | MKCoordinateSpan编码成NSValue |
| MKLaunchOptionsShowsTrafficKey | 交通状况，BOOL值 | 0 1 |
| MKLaunchOptionsCameraKey | 一个Object | MKMapCamera的实例 |

placeMark

是MapItem的一个对象，包含了基本信息例如电话、URL等等，用于实例化MapItem，本身可以通过 initWithCoordinate: 实例化

实例化方法

实例化 备注
+ mapItemForCurrentLocation 返回当前设备的MapItem，是一个单例
- initWithPlacemark: 通过PlaceMark进行实例化

示例代码

从当前位置导航到某个目的地

1
2
3
4
5
6
CLLocationCoordinate2D drone = _mapKit.drone.coordinate;
MKMapItem *currentLocation = [MKMapItem mapItemForCurrentLocation];
MKMapItem *toLocation = [[MKMapItem alloc] initWithPlacemark:[[MKPlacemark alloc] initWithCoordinate:drone]]; //目的地坐标
toLocation.name = @"目的地"; //目的地名字
[MKMapItem openMapsWithItems:@[currentLocation, toLocation] launchOptions:@{MKLaunchOptionsDirectionsModeKey: MKLaunchOptionsDirectionsModeWalking,MKLaunchOptionsShowsTrafficKey: [NSNumber numberWithBool:NO]}];

展开全文 >>

MKMapKit(四)：拦截地图的操作手势

拦截地图手势

通过私有类去找私有手势

不推荐使用该方法，但是也是我想出来的奇技淫巧，所以就记下来了

在[文章三][link01]中我们可以通过View Tree去找到ContentView，所以说也可以通过该View找到MKMapKit默认存在的手势接收器 _MKUserInteractionGestureRecognizer，如下代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
- (void)mapView:(MKMapView *)mapView didAddAnnotationViews:(NSArray<MKAnnotationView *> *)views {
    if (!_renderView) {
        _renderView = [views firstObject].superview;
        [_renderView.superview.gestureRecognizers enumerateObjectsUsingBlock:^(__kindof UIGestureRecognizer *obj, NSUInteger idx, BOOL *stop) {
            if([NSStringFromClass([obj class]) isEqualToString:@"_MKUserInteractionGestureRecognizer"]) {
                _userInteractionGesture = obj;
                [obj addObserver:self forKeyPath:@"state" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:@"MapView"];
            }
        }];
    }
    //Auto Correct
    [self autoCorrectLocationOffset];

}

通过对其State添加KVO即可接收到地图手势的触发状态，并且进行逻辑判断

1
2
3
4
5
6
7
8
9
10
11
//Normal Gesture
if([NSStringFromClass([object class]) isEqualToString:@"_MKUserInteractionGestureRecognizer"]) {
    if (_userInteractionGesture.state == UIGestureRecognizerStateChanged) {
        [self handleAnnotationShapesUpdateHidden:NO];
    }
    if(_userInteractionGesture.state == UIGestureRecognizerStateEnded) {
        if(MKMapRectEqualToRect(_tempVisibleRect, self.visibleMapRect)) {
            [self handleAnnotationShapesUpdateHidden:NO];
        }
    }
}

共同触发接收器

通过添加新的GestureRecognizer来监听手势，通过设置代理 gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer: 来同时触发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
- (void)monitorGesture {
    UIPinchGestureRecognizer *pinchGestureRecognizer = [[UIPinchGestureRecognizer alloc] initWithTarget:self action:@selector(receiveGesture:)];
    UIPanGestureRecognizer *panGestureRecognizer = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(receiveGesture:)];
    UITapGestureRecognizer *tapGestureRecognizer = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(receiveGesture:)];
    UIRotationGestureRecognizer *rotationGestureRecognizer = [[UIRotationGestureRecognizer alloc] initWithTarget:self action:@selector(receiveGesture:)];
    pinchGestureRecognizer.delegate = self;
    panGestureRecognizer.delegate = self;
    tapGestureRecognizer.delegate = self;
    rotationGestureRecognizer.delegate = self;
    [self addGestureRecognizer:pinchGestureRecognizer];
    [self addGestureRecognizer:panGestureRecognizer];
    [self addGestureRecognizer:tapGestureRecognizer];
    [self addGestureRecognizer:rotationGestureRecognizer];
}

- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
    return YES;
}

- (void)receiveGesture:(UIGestureRecognizer *)recognizer {
  ..............
}

展开全文 >>

MKMapKit(三)：获得ContainerView

为什么要获取ContainerView

在有些需求中，要求一个Annotation上添加一个View并且要处于另外一个Annotation的下面，因为Annotation本身只有一个View接收Image，想要实现这个效果旧代码采取了

  • 每个Annotation都做两个，添加在底下的那个Annotation上

感觉不是优秀的处理方法，所以通过IDE观察View Tree，可以发现，所有的AnnotationView都加在一个共同的ContentView上，整个MapView的结构关系为

1
2
3
4
5
6
7

------_MKMapContentView                   <----这个是基础的MapView
--------MKBasicMapView                    <----这个是地图基础地图，就是显示街道和建筑的那层
--------MKScrollContainerView             <----这个是个不存在Frame的虚拟层，猜测负责滚动等
--------MKNewAnnotationContainerView      <----这个是一个透明层，负责承载AnnotationView
----------XXXAnnotationView               <----这个是自定义的AnnotationView

所以我们可以简单的通过superView来获得 AnnotationContainerView 如果在这上边添加View，就可以保证其处于所有AnnotationView底层

获取代码

1
2
3
4
5
6
7
8
9
10
11
//保存一个指向ContainerView的弱指针
@property (nonatomic, weak) UIView *renderView;


//捕捉ContainerView
- (void)mapView:(MKMapView *)mapView didAddAnnotationViews:(NSArray<MKAnnotationView *> *)views {
    if (!_renderView) {
        _renderView = [views firstObject].superview;
    }
}

根据需求补充

如果仅仅是完成第一段所说的需求，也可以通过监控代理，把每次特定的View使用函数置底，来做到让其显示在所有View底部

1
2
UIView *view = [_mapView viewForAnnotation:_annotation];
[view.superview sendSubviewToBack:view]

展开全文 >>

MKMapKit(二)：自动纠偏

基本思路

  1. 地图DidAppear后获取到MKMapKit自身蓝色小圆点的Frame值
  2. 地图DidAppear后获取到由LocationManage产生的Annotation对应的AnnotationView的Frame值
  3. 对比AnnotationView和BlueDot的Frame或者反推的Location来确定是否重叠
  4. 不重叠进行自动纠偏

如何获取BlueDot

通过Annotation获得

通过 mapView:viewForAnnotation: 获得Annotation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//指向BlueDot的Weak指针
@property (nonatomic, weak) MKUserLocation *blueDot;


//通过拦截获取到BlueDot
- (MKAnnotationView *)mapView:(MKMapView *)mapView viewForAnnotation:(id <MKAnnotation>)annotation {
    // If the annotation is the user location, just return nil.
    if ([annotation isKindOfClass:[MKUserLocation class]]) {
        _blueDot = annotation;
        return nil;
    }
 return nil;
}

//获取到BlueDot的AnnotationView
MKAnnotationView *tempBlue = [self viewForAnnotation:_blueDot];

通过AnnotationView获得

通过 mapView: didAddAnnotationViews: 直接获得AnnotationView

1
2
3
4
5
6
7
8
9
10
11
12
//指向BlueDotView的Weak指针
@property (nonatomic, weak) MKAnnotationView *blueDotView;


//利用MKMapKit的用户View是苹果的私有类 类名为MKModernUserLocationView，不可能被继承或者重用
- (void)mapView:(MKMapView *)mapView didAddAnnotationViews:(NSArray<MKAnnotationView *> *)views {
    [views enumerateObjectsUsingBlock:^(MKAnnotationView *obj, NSUInteger idx, BOOL *stop) {
        if([NSStringFromClass([obj class]) isEqualToString:@"MKModernUserLocationView"]) {
            _blueDotView =  obj;
        }
    }];
}

位置比较

位置比较可以直接比较Frame，但是在不同Scale下，并不是太稳定，所以选择通过CGPoint的位置反推Coordinate，然后通过CLLocationDistance来确定两者是否重合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
- (void)autoCorrectLocationOffset {
    if (!_blueDot) {
        return;
    }
    MKAnnotationView *tempBlue = [self viewForAnnotation:_blueDot];
    if (!tempBlue) {
        return;
    }
    //获取通过View反推的Coordinate
    CLLocationCoordinate2D tempApple = [self convertPoint:tempBlue.center toCoordinateFromView:self];
    CLLocationCoordinate2D tempUser = [self convertPoint:[self viewForAnnotation:_user].center toCoordinateFromView:self];
    //获取Coordinate生成的CLLocation
    CLLocation *blueDot = [[CLLocation alloc] initWithLatitude:tempApple.latitude longitude:tempApple.longitude];
    CLLocation *user = [[CLLocation alloc] initWithLatitude:tempUser.latitude longitude:tempUser.longitude];
    //计算两者绝对距离
    CLLocationDistance distance = [blueDot distanceFromLocation:user];
    //设置是否纠偏
    if (distance > 50 ) {
        [[AppSettings instance] setNeedCalibrateCoordinate:![AppSettings instance].needCalibrateCoordinate];
    }
}

纠偏策略

由于自动纠偏探测依赖于不稳定的ViewTree，所以很可能出现在卡顿的时候自动纠偏方法被连续调用两次（多出现于旧款iPad），所以需要制定一个可靠的纠偏策略，目前采用的策略：

  • 在地图RegionChange时检查是否纠偏
  • 在新的AnnotationView出现在MapView上时检测是否纠偏
  • 通过拦截手势在用户操作时触发

存在问题

  1. 地图加载完毕后BlueDotView并不一定会出现在地图上，所以需要手动控制地图Zoom到某个Region保证BlueDotView出现
  2. BlueDotView闪现，可能会导致多次调用

小技巧

BlueDot的AnnotationView虽然不一定会出现在MapView上，但是不管MapView.showUser = ？多少，MapView的用户Annotation对象 MKUserLocation 永远会存在于地图上

如果想使用自己的Image来作为用户的AnnotationView，可以不再一开始就隐藏MapView.showUser，使用其作为参考点后再设置隐藏，因为BlueDotView实际被Add到MapView上时，并未进入Screen范围

用户的AnnotationView与BlueDotView时，实际是存在自己的AnnotationView的，可以采用赋值Image为nil的形式让其以透明样式存在

展开全文 >>

MKMapKit(一)：火星坐标坐标系转换

火星坐标转换

由于你懂的原因，国内有些GPS坐标需要转换，国内的GPS体系名称叫 GCJ02 而国际通用的叫 WGS84 下面是魔法代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

const static double a = 6378245.0;
const static double ee = 0.00669342162296594323;
const static double pi = M_PI;

static float calculateDegree(float degree, float minute, float second)
{
    return degree + (minute + (second / 60.0)) / 60.0;
}

#define D(x,y,z) calculateDegree(x, y, z)


+ (CLLocationCoordinate2D)gcj02FromWGS84:(CLLocationCoordinate2D)wgs {


    CLLocationCoordinate2D gcj = kCLLocationCoordinate2DInvalid;
    double wgLon = wgs.longitude;
    double wgLat = wgs.latitude;
    if (outOfChinaLand(wgs.latitude, wgs.longitude))
    {
        gcj.latitude = wgs.latitude;
        gcj.longitude = wgs.longitude;
        return gcj;
    }
    double dLat = transformLatitude(wgLon - 105.0, wgLat - 35.0);
    double dLon = transformLongitude(wgLon - 105.0, wgLat - 35.0);
    double radLat = wgLat / 180.0 * pi;
    double magic = sin(radLat);
    magic = 1 - ee * magic * magic;
    double sqrtMagic = sqrt(magic);
    dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
    dLon = (dLon * 180.0) / (a / sqrtMagic * cos(radLat) * pi);
    gcj.latitude = wgLat + dLat;
    gcj.longitude = wgLon + dLon;

    return gcj;
}

+ (CLLocationCoordinate2D)wgs84FromGCJ02:(CLLocationCoordinate2D)gcj {

    if (outOfChinaLand(gcj.latitude, gcj.longitude)) {
        return gcj;
    }
    CLLocationCoordinate2D latLng = offsetDelta(gcj);
    double latitude = gcj.latitude - latLng.latitude;
    double longitude = gcj.longitude - latLng.longitude;
    return CLLocationCoordinate2DMake(latitude, longitude);
}

static bool outOfChinaLand(double lat, double lon)
{
    CGRect taiwan = CGRectMake(21.5, 120.2, 4, 2);
    bool isContain = CGRectContainsPoint(taiwan, CGPointMake(lat, lon));
    if (isContain) {
        return true;
    }

    CGPathRef path = [self getChinaBoundingPath];
    if (CGPathContainsPoint(path, NULL, CGPointMake(lat, lon), false)) {
        return false;
    }

    return true;
}

static double transformLatitude(double x, double y)
{
    double ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * sqrt(fabs(x));
    ret += (20.0 * sin(6.0 * x * pi) + 20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0;
    ret += (20.0 * sin(y * pi) + 40.0 * sin(y / 3.0 * pi)) * 2.0 / 3.0;
    ret += (160.0 * sin(y / 12.0 * pi) + 320 * sin(y * pi / 30.0)) * 2.0 / 3.0;
    return ret;
}

static double transformLongitude(double x, double y)
{
    double ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * sqrt(fabs(x));
    ret += (20.0 * sin(6.0 * x * pi) + 20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0;
    ret += (20.0 * sin(x * pi) + 40.0 * sin(x / 3.0 * pi)) * 2.0 / 3.0;
    ret += (150.0 * sin(x / 12.0 * pi) + 300.0 * sin(x / 30.0 * pi)) * 2.0 / 3.0;
    return ret;
}

+(CGPathRef) getChinaBoundingPath
{
    static CGMutablePathRef pathRef = NULL;
    if (pathRef == NULL) {
        pathRef = CGPathCreateMutable();

        CGPathMoveToPoint(pathRef, NULL, D(48,58,42.64), D(87, 5, 59.19));
        CGPathAddLineToPoint(pathRef, NULL, D(46, 43, 33.27), D(85, 25, 26.56));
        CGPathAddLineToPoint(pathRef, NULL, D(47, 00, 18.85), D(83, 13, 32.25));
        CGPathAddLineToPoint(pathRef, NULL, D(44, 51, 45.02), D(79, 52, 21.83));
        CGPathAddLineToPoint(pathRef, NULL, D(42, 06, 38.75), D(80, 16, 38.32));
        CGPathAddLineToPoint(pathRef, NULL, D(40, 26, 33.02), D(74, 52, 43.66));
        CGPathAddLineToPoint(pathRef, NULL, D(38, 46, 42.06), D(73, 45, 47.54));
        CGPathAddLineToPoint(pathRef, NULL, D(35, 40, 53.53), D(77, 17, 50.18));
        CGPathAddLineToPoint(pathRef, NULL, D(35, 18, 19.61), D(80, 25, 3.57));
        CGPathAddLineToPoint(pathRef, NULL, D(33, 47, 49.88), D(79, 4, 29.33));
        CGPathAddLineToPoint(pathRef, NULL, D(31, 30, 12.49), D(78, 27, 15.10));
        CGPathAddLineToPoint(pathRef, NULL, D(29, 56, 32.62), D(81, 15, 44.46));
        CGPathAddLineToPoint(pathRef, NULL, D(27, 11, 56.65), D(89, 01, 43.60));
        CGPathAddLineToPoint(pathRef, NULL, D(28, 12, 41.71), D(97, 27, 43.41));
        CGPathAddLineToPoint(pathRef, NULL, D(25, 53, 39.08), D(98, 48, 8.70));
        CGPathAddLineToPoint(pathRef, NULL, D(24, 39, 34.05), D(97, 28, 21.20));
        CGPathAddLineToPoint(pathRef, NULL, D(23, 45, 59.97), D(97, 39, 54.56));
        CGPathAddLineToPoint(pathRef, NULL, D(21, 06, 32.01), D(101, 21, 31.23));
        CGPathAddLineToPoint(pathRef, NULL, D(22, 39, 01.59), D(103, 26, 4.0));
        CGPathAddLineToPoint(pathRef, NULL, D(20, 16, 53.73), D(107, 49, 47.06));
        CGPathAddLineToPoint(pathRef, NULL, D(15, 47, 06.87), D(108, 54, 19.46));
        CGPathAddLineToPoint(pathRef, NULL, D(14, 53, 53.70), D(114, 38, 35.08));
        CGPathAddLineToPoint(pathRef, NULL, D(21, 04, 46.90), D(121, 47, 25.12));
        CGPathAddLineToPoint(pathRef, NULL, D(30, 04, 39.55), D(125, 46, 41.78));
        CGPathAddLineToPoint(pathRef, NULL, D(39, 29, 30.38), D(123, 11, 52.45));
        CGPathAddLineToPoint(pathRef, NULL, D(42, 46, 30.75), D(131, 10, 38.60));
        CGPathAddLineToPoint(pathRef, NULL, D(48, 15, 27.43), D(134, 46, 49.54));
        CGPathAddLineToPoint(pathRef, NULL, D(49, 29, 41.88), D(127, 50, 21.50));
        CGPathAddLineToPoint(pathRef, NULL, D(53, 06, 13.32), D(125, 9, 54.19));
        CGPathAddLineToPoint(pathRef, NULL, D(52, 52, 56.58), D(119, 52, 42.41));
        CGPathAddLineToPoint(pathRef, NULL, D(48, 05, 29.20), D(115, 17, 35.36));
        CGPathAddLineToPoint(pathRef, NULL, D(46, 32, 0.41), D(119, 44, 29.70));
        CGPathAddLineToPoint(pathRef, NULL, D(44, 36, 38.94), D(111, 41, 41.13));
        CGPathAddLineToPoint(pathRef, NULL, D(42, 13, 8.78), D(107, 12, 24.35));
        CGPathAddLineToPoint(pathRef, NULL, D(42, 43, 53.70), D(96, 26, 11.34));
        CGPathAddLineToPoint(pathRef, NULL, D(44, 44, 42.52), D(93, 47, 30.02));
        CGPathAddLineToPoint(pathRef, NULL, D(45, 18, 42.86), D(90, 47, 27.32));
        CGPathAddLineToPoint(pathRef, NULL, D(47, 45, 6.43), D(90, 10, 4.97));

        CGPathCloseSubpath(pathRef);
    }

    return pathRef;
}

static CLLocationCoordinate2D offsetDelta(CLLocationCoordinate2D source)
{
    double dLat;
    double dLng;
    double a = 6378245.0;
    double ee = 0.00669342162296594323;
    dLat = transformLatitude(source.longitude-105.0, source.latitude-35.0);
    dLng = transformLongitude(source.longitude-105.0, source.latitude-35.0);
    double radLat = source.latitude / 180.0 * M_PI;
    double magic = sin(radLat);
    magic = 1 - ee*magic*magic;
    double sqrtMagic = sqrt(magic);
    dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * M_PI);
    dLng = (dLng * 180.0) / (a / sqrtMagic * cos(radLat) * M_PI);
    return CLLocationCoordinate2DMake(dLat, dLng);
}

#undef D(x,y,z)

展开全文 >>

Java多线程预习小笔记

多线程

多线程的基本知识我是参考了以下文章

  1. Java多线程的基本概念: 讲了一些基本概念
  2. 林炳文Evankaka的多线程解析: 讲了一些多线程的经典例题和一些博主自己的总结，写的十分不错
  3. Synchronized及其实现原理: 简述了多线程中关键字Synchronized的实现原理
  4. CountDownLatch与CyclicBarrier: 多线程编程中一些控制方法

本文在以上文章的基础上，说说我自己的理解(思维回路可能比较奇怪)，对一些没有提到的细节进行补充

多线程的实现方式

多线程有几种实现方式，这是好多面试题里问的，一般来说网上的答案是这样三个或者文章Java实现多线程的四个方式这样的

1
2
3
4
5
6
7
//一般是这三个
1、继承Thread类创建线程
2、实现Runnable接口创建线程
3、实现Callable接口通过FutureTask包装器来创建Thread线程

//这个作者理解错了
4、使用ExecutorService、Callable、Future实现有返回结果的线程(这个是错的，参考下文)

这些方式有时候是三个，有时候是四个，他们有什么区别呢？先说结论: 多线程只有一个实现方式，就是实现Runnable接口， 并且使用Thread进行开启

继承Thread类

正确的理解方式 Thread类本身就是一个实现了Runnable接口的类，继承它相当于实现了Runnable 好处是在于不用使用Thread去包装Runnable了

1
2
3
4
5
6
7
8
9
10
public class MyThread extends Thread {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  

MyThread myThread1 = new MyThread();  <==这里可以直接new，不用包装
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();

实现Runnable接口

需要使用Thread进行包装才能开启线程

1
2
3
4
5
6
7
8
class RunnableDemo implements Runnable {
  public void run() {  
  　　 System.out.println("MyThread.run()");  
  　　}  
}

Thread thread = new Thread(new RunnableDemo(), "threadName");  <==需要使用Thread包装
thread.start ();

Callable 和 FutureTask

正确的理解方式是 FutureTask本身实现了RunnableFuture，RunnableFuture继承于Runnable和Future，FutureTask可以通过Callable进行实例化，实例化的对象相当于实现了Runnable 得到了FutureTask还需要通过Thread包装才能开启线程

1
2
3
4
5
6
7
8
9
10
11
12
13
//1. 新建一个实现了Callable的类
public class CallableObj implements Callable<String> {
    public String call() throws Exception {
        return null;
    }
}

//2. 使用FutureTask包装Callable
FutureTask future = new FutureTask(new CallableObj());

//3. 使用Thread包装FutureTask
Thread thread = new Thread(future);
thread.start()

多线程解析

先来看单词

单词 意思 意义
Thread 线程 所谓多线程，就是指的多个Thread
Runnable 可以跑，即可以执行 每个Thread都需要一个可以执行的东西
Callable 可以调用 可以调用的意思，是可以回调，相当于JS里的callback，iOS里的block
Future 未来 异步任务，配合回调函数，相当于JS里的Promise

从上表分析

  • Thread和Runnable是互相对应共同存在的，这两个才是线程操作的概念
  • 而Future和Callable是另一个概念集合，属于异步和回调

他们四个都属于Concurrent的Package，也就是说都属于并发(Concurrent)包

Thread和Runnable代表线程操作

每个Thread中有一个Runnable成员target

  • 如果是继承的Thread的类，在new的时候会把target指向this
  • 如果是通过Runnable的Object实例化的Thread，target会指向这个Object

当调用了Thread的start方法之后，Thread会进入可执行状态(Runnable)，然后在被CPU执行时，Thread调用自己的run方法，方法内执行Target的run方法

Future和Callable代表异步和回调

Future英文直译是未来的意思，也就是不是当下发生的事情，而Callable代表可以调用

  • Future本身是一个对异步的控制Interface，包括取消，挂起和执行
  • Callable是只有一个call方法，返回一个V范型的返回值
  • FutureTask是一个Class，实现了Runnable，Future的Interface，可以通过Callable进行实例化

综上所属，所谓的第三种可以通过Callable实现多线程，就是扯淡。。。 只不过FutureTask刚好就是一个实现了Runnable的Object，所以可以用来实例化Thread，而FutureTask的实例化恰好需要Callable而已

ExecutorService是什么(为什么上文第四个多线程方法是扯淡)

ExecutorService是一个Interface，继承于Executor，其可以通过静态方法获取到实例，好像俗称 线程池 呃 我不确定

1
ExecutorService executorService = Executors.newCachedThreadPool();

其本质是一个通过Future、Callable、Runnable来规划并发任务的容器，Future负责任务管理，Runnable负责任务逻辑代码，Callable负责返回值

Executor这个Interface只有一个方法，就是execute(Runnable command)，执行某个可以Runnable的命令，而ExecutorService则在继承其基础上，提供了3个主要方法

1
2
3
4
5
6
7
8
//提交一个Callable的对象，并且通过Future拿到返回值
<T> Future<T> submit(Callable<T> task);

//提交一个Runnable的对象，并且通过Future拿到返回值，返回值为T
<T> Future<T> submit(Runnable task, T result);

//提一个Runnable的对象，并且通过Future拿到返回值null
Future<?> submit(Runnable task);

根据上文陈述， Runnable接口只是负责线程Thread中的Target执行什么 所以不具有返回值，如果想要得到ExecutorService执行的返回值，必须使用Callable接口，并且使用Future.get()获得，所以以上3个submit分别做了以下操作

方法 取得返回值原理
submit(Callable task) 提交的就是一个Callable对象，所以可以得到返回值
submit(Runnable task, T result) 提交的Runnable对象不具有返回值，在ExecutorService，内部使用一个FutureTask对象，用T result来实例化FutureTask的Callable对象，从而得到期望的T范型返回值
submit(Runnable task) Runnable没有返回值，那就不要返回值了，执行完直接返回null

可以看出，之所以submit(Runnable task, T result)可以获得返回值，是因为在ExecutorService内部使用了FutureTask对象，这个对象内部有callable对象来确定返回值。这也说明来Java实现多线程的四个方式文章中的所谓第四个方式是没看源码

多线程控制

使用Object锁

在文章林炳文Evankaka的多线程解析中讲到了一个经典的例题

  • 建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。

使用到了Object的wait()和notify()，这里进行补充解析来阐明什么叫Object锁，基本原理请参考林炳文的文章

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/**
 * wait用法
 * @author DreamSea
 * @time 2015.3.9
 */
package com.multithread.wait;
public class MyThreadPrinter2 implements Runnable {   

    private String name;   
    private Object prev;   
    private Object self;   

    private MyThreadPrinter2(String name, Object prev, Object self) {   
        this.name = name;   
        this.prev = prev;   
        this.self = self;   
    }   

    @Override  
    public void run() {   
        int count = 10;   
        while (count > 0) {   
            synchronized (prev) {   
                synchronized (self) {   
                    System.out.print(name);   
                    count--;  
                    self.notify();   
                }   
                try {   
                    prev.wait();   
                } catch (InterruptedException e) {   
                    e.printStackTrace();   
                }   
            }   

        }   
    }   

    public static void main(String[] args) throws Exception {   
        Object a = new Object();   
        Object b = new Object();   
        Object c = new Object();   
        MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);   
        MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);   
        MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);   


        new Thread(pa).start();
        Thread.sleep(100);  //确保按顺序A、B、C执行
        new Thread(pb).start();
        Thread.sleep(100);  
        new Thread(pc).start();   
        Thread.sleep(100);  
        }   
}

在程序中有一行注释

1
Thread.sleep(100);  //确保按顺序A、B、C执行

十分重要，如果不使用Thread.sleep的话，会输出结果ACB循环而不是ABC，为什么是这样的呢？

1
ACBACBACBACBACBACBACBACBACBACB

Object锁顺序分析

我们在分析图标中用不同的符号代表状态

  • x 代表 当前获得了Object锁还未执行打印
  • ~x 代表 即将执行却由于获取不到Object锁被挂起
  • !x 代表 完成了打印结果 并且释放Object锁
  • ?x 代表 执行了wait() 并且释放Object锁

不加sleep(100)的情况

对象 1 2 3 4 5 6 7 8
A c a c !a ?c !a c ~a c ~a c ~a c a c a
B ~a a ~b a ~b a ~b a b a !b ?a !b ~a
C b ~c b ~c b c b !c ?b !c b ~c b ~c b ~c
输出 null A A AC AC ACB ACB 循环

加了sleep(100)的情况

对象 1 2 3 4 5 6 7 8
A c a c !a ?c !a ?c !a ?c !a ?c !a c !a c a
B sleep sleep a b a !b ?a !b ?a !b ?a !b ?a
C sleep sleep sleep sleep b ~c b !c ?b !c ?b
输出 null A A AB AB ABC ACB 循环

在第8步进入 B对象Thread执行了a.wait，而C对象线程执行了b.wait 之后等同于第一步的两者都在sleep，经过以上分析，我们可以得知sleep就是通过这种方式保证了ABC的顺序

如果将sleep改为1000毫秒，可以清楚的看到，第一组ABC打印使用了3秒以便进入步骤8，剩余的则是瞬时完成的

使用控制器

除了使用Object锁自己进行线程控制之外，Concurrent包内部也提供了一些控制器，比如文章CountDownLatch与CyclicBarrier中提到的

  1. CountDownLatch: 计数(Count)减少(Down)门挡(Latch)，Latch这个单词是门闩的意思，就是关门的那个横木，从字面意思可以理解出来，这就是个计数器，一旦计数减少到某一阈值，就触发
  2. CyclicBarrier: 循环(Cyclic)遮挡(Barrier),Barrier这个是火车道那种一堆人一起的遮挡，意思就是必须所有人等待一起过，和Latch这个横木不一样，是周期性的遮挡的放开，所以叫Cyclic，这个周期就是你设定的第一个参数

结语

这个文章很早就写好了，一直没有发表，当时为了Java而写的，后来在iOS里也发现了相似的机制，同样具有 synchronized 关键词和上文的两个控制器，但是iOS为了追求效率，大部分称需要喜欢自己手动控制锁。。。所以就很容易死锁。。。后台不一样，后台保证稳定性是第一的，所以更注重synchronized的理解

展开全文 >>

终端下为npm和git配置Shadowsocks

终端下的代理

通过文章MacOS 10.12 终端命令行下使用Shadowsocks我们得知Shadowsocks-NG可以提供HTTP和HTTPS代理了,那么我们可以单独为某些命令配置代理

为npm配置代理

参考文章npm的配置文件npmrc，我们可以在Mac下新建一个配置文件

1
vim ~/.npmrc

在文件内写入

1
2
proxy = http://127.0.0.1:1087
https-proxy = http://127.0.0.1:1087

然后保存退出即可，如果想使用命令直接配置，参考文章命令配置npmrc,其中也对配置文件进行更详细的解释

npm获取配置有6种方式，优先级由高到底

  1. 命令行参数。 –proxy http://server:port即将proxy的值设为http://server:port。
  2. 环境变量。 以npm_config_为前缀的环境变量将会被认为是npm的配置属性。如设置proxy可以加入这样的环境变量npm_config_proxy=http://server:port。
  3. 用户配置文件。可以通过npm config get userconfig查看文件路径。如果是mac系统的话默认路径就是$HOME/.npmrc。
  4. 全局配置文件。可以通过npm config get globalconfig查看文件路径。mac系统的默认路径是/usr/local/etc/npmrc。
  5. 内置配置文件。安装npm的目录下的npmrc文件。
  6. 默认配置。 npm本身有默认配置参数，如果以上5条都没设置，则npm会使用默认配置参数。

为Git配置代理

首先Git分为3种协议模式

协议 是否可以使用HTTP代理
git:// 不能直接使用
http:// 可以
https:// 可以

命令行配置

1
2
3
4
5
6
7
8
//配置
git config --global core.gitproxy proxy
git config --global http.proxy http://127.0.0.1:1087
git config --global https.proxy https://127.0.0.1:1087
//取消
git config --global --unset core.gitproxy
git config --global --unset http.proxy
git config --global --unset https.proxy

修改配置文件

git的配置文件位于

1
vim ~/.gitconfig

如果我们进行了代理配置，可以看到

1
2
3
4
5
6
[core]
        gitproxy = proxy
[http]
        proxy = http://127.0.0.1:1087
[https]
        proxy = https://127.0.0.1:1087

展开全文 >>

MacOS 10.12 终端命令行下使用Shadowsocks

无穷无尽的战斗

方校长今年还说想为祖国再尽一份余力，真是可喜可贺啊

Shadowsocks-NG

有一个新的Shadowsocks的客户端叫 Shadowsocks-NG 解决了一个长久以来的痛点，Shadowsocks没有HTTP代理，导致我们需要使用polipo等软件进行协议转换

image01
image02

现在其在1087端口提供了http代理服务，我们可以通过在命令行直接设置代理，来使用SS服务了

1
2
3
4
5
6
//开启代理
export http_proxy=127.0.0.1:1087
export https_proxy=127.0.0.1:1087
//关闭代理
unset http_proxy
unset https_proxy

配置一个别名方便启动

1
vim ~/.bash_profile

在文件内加入

1
2
3
# Custom Add not System
alias proxy-on='export http_proxy=127.0.0.1:1087;export https_proxy=$http_proxy'
alias proxy-off='unset http_proxy;unset https_proxy'

就可以在命令行内通过 proxy-on 和 proxy-off 来开启关闭代理

sudo操作怎么办

以上快捷启动配置只能在User的命令行里进行使用，如果想对sudo操作挂proxy，需要先使用命令

1
sudo -s

进入bash 3.2# 然后手动设置

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

我写的，大概率是错的。。。。。