• 定义抽象消息载体


• 基本的消息发送


• 基本的消息回调


• 定义基本的通知

• 登录注册


• 消息收发，支持TXT, IMAGE, VIDEO, AUDIO, FILE, LOCATION, 类型的message


• 会话管理


• 联系人管理

• 线程模型，利用C++11的thread进行封装


• 数据库模型，使用Linux的sqlite


• HTTP模型，我们使用了Libcurl进行了封装


• 定时器模型，我们使用了C++11进行了封装

1. 在Windows PC上，利用ADS（ARM 开发环境），使用armcc编译器，则可编译出针对ARM CPU的可执行代码。
2. 在Linux PC上，利用arm-linux-gcc编译器，可编译出针对Linux ARM平台的可执行代码。
3. 在Windows PC上，利用cygwin环境，运行arm-elf-gcc编译器，可编译出针对ARM CPU的可执行代码。

• >>make: 根据Makefile编译源代码，连接，生成目标文件，可执行文件;


• >>make clean: 清除上次的make命令所产生的object文件（后缀为“.o”的文件）及可执行文件;


• >>make distclean: 类似make clean，但同时也将configure生成的文件全部删除掉，包括Makefile；


• >>make test / make check: 检查make，确保make没有出错，一般在make install之前执行；


• >>make install: 将编译成功的可执行文件安装到指定目录中，一般为/usr/local/bin目录;


• >>make dist: 产生发布软件包文件（即distribution package）。这个命令将会将可执行文件及相关文件打包成一个tar.gz压缩的文件用来作为发布软件的软件包。它会在当前目录下生成一个名字类似“PACKAGE-VERSION.tar.gz”的文件。PACKAGE和VERSION，是我们在configure.in中定义的AM_INIT_AUTOMAKE(PACKAGE, VERSION);


• >>make distcheck: 生成发布软件包并对其进行测试检查，以确定发布包的正确性。这个操作将自动把压缩包文件解开，然后执行configure命令，并且执行make，来确认编译不出现错误，最后提示你软件包已经准备好，可以发布了; 

• step1.下载树莓派交叉编译工具https://github.com/raspberrypi/tools


• step2. 将源码放到各用户都能share的文件夹下，如/usr/tools


• step3. 将交叉编译工具的路径加到环境变量中，为了以后启动不用再设置，我加到了bashrc中

1 $nano ~/.bashrc

2 #在文件的末尾加上： export PATH=$PATH:/usr/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin

3 $source .bashrc

• step4. 检测是否安装成功

$arm #双tab

$arm-linux-gnueabihf-gcc -v 

#能显示正确信息



$arm-linux-gnueabihf-g++ -v 

#能显示正确信息

1 demo: $(obj)

2     $(CXX) -o $@ $^ $(LDFLAGS)

1 $export CC=arm-linux-gnueabihf-gcc  

2 $export CXX=arm-linux-gnueabihf-g++ 

• step1:  make clean


• step2:  ./configure --host=arm-linux-gnueabihf --prefix=/usr/local/tools/sqlite3


• step3:  make


• step4:  make install

• step1:  make clean


• step2:  ./configure --host=arm-linux-gnueabihf --prefix=/usr/local/tools/curl


• step3:  make


• step4:  make install

• step1: ./config no-asm shared --prefix=/usr/local/tools/openssl


• step2:  a、修改Makefile CC=arm-linux-gnueabihf-gcc

• step3: make


• step4: make install

• 别相信表单

• 别相信用户

• 关闭全局变量

register_globals = Off 

['post_value'];$get_value = $_GET['get_value'];$some_variable = $_REQUEST['some_value']; ?>  

• register_globals 设置为 off
• safe_mode 设置为 off
• error_reporting 设置为 off。如果出现错误了，这会向用户浏览器发送可见的错误报告信息。对于生产服务器，使用错误日志代替。开发服务器如果在防火墙后面就可以启用错误日志。（LCTT 译注：此处据原文逻辑和常识，应该是“开发服务器如果在防火墙后面就可以启用错误报告，即 on。”）
• 停用这些函数：system()、exec()、passthru()、shell_exec()、proc_open()、和 popen()。
• open_basedir 为 /tmp（以便保存会话信息）目录和 web 根目录，以便脚本不能访问这些选定区域外的文件。
• expose_php 设置为 off。该功能会向 Apache 头添加包含版本号的 PHP 签名。
• allow_url_fopen 设置为 off。如果你能够注意你代码中访问文件的方式-也就是你验证所有输入参数，这并不严格需要。
• allow_url_include 设置为 off。对于任何人来说，实在没有明智的理由会想要访问通过 HTTP 包含的文件。
•  
• 一般来说，如果你发现想要使用这些功能的代码，你就不应该相信它。尤其要小心会使用类似 system() 函数的代码-它几乎肯定有缺陷。
• 启用了这些设置后，让我们来看看一些特定的攻击以及能帮助你保护你服务器的方法。

$sql = "select * from pinfo where product = '$product'";

$sql = 'Select * from pinfo where product = '"'        mysql_real_escape_string($product) . '"';

39'; DROP pinfo; SELECT 'FOO 

select product from pinfo where product = '39'; DROP pinfo; SELECT 'FOO' 

select * from pinfo where product = '39'DROP pinfoSELECT 'FOO' 

• 总是验证所有参数。例如，如果需要一个数字，就要确保它是一个数字。
• 总是对数据使用 mysql_real_escape_string() 函数转义数据中的任何引号和双引号。

function transform_HTML($string, $length = null) {// Helps prevent XSS attacks    // Remove dead space.    $string = trim($string);    // Prevent potential Unicode codec problems.    $string = utf8_decode($string);    // HTMLize HTML-specific characters.    $string = htmlentities($string, ENT_NOQUOTES);    $string = str_replace("#", "#", $string);    $string = str_replace("%", "%", $string);    $length = intval($length);    if ($length > 0) {        $string = substr($string, 0, $length);    }    return $string;} 

Bold Text

Bold Text 

alert('XSS Attack')";// Create a safehtml object.$safehtml = new safehtml();// Parse and sanitize the data.$safe_data = $safehtml->parse($data);// Display result.echo 'The sanitized data is 
' . $safe_data;?>

function hash_ish($string) {    return md5($string);}

 0) &&        (! is_null($num_chars))) {        $password = '';        $accepted_chars = 'abcdefghijklmnopqrstuvwxyz1234567890';        // Seed the generator if necessary.        srand(((int)((double)microtime()*1000003)) );        for ($i=0; $i<=$num_chars; $i++) {            $random_number = rand(0, (strlen($accepted_chars) -1));            $password .= $accepted_chars[$random_number] ;        }        return $password;     }}?> 

1. 在tableView类型的展示列表中，点击每个cell中人物头像都可以跳转到人物详情，可参见微博中的头像，同理包括转发、评论按钮、各种链接及linkcard。
2. 跳转到任意页面

• 产品要求，某个页面的不同banner图，点击可以跳转到任何一个页面，可能是原生的页面A、页面B，或者是web页C。
• 在web页面，可以跳转到任何一个原生页面。
• 在远程推送中跳转到任意指定的页面。

• 与后端约定好数据结构，例如：

NSDictionary *target = @{@"action" : @"user",                         @"data"   : @{@"user_id" : @(123456)}};

• 创建一个用来跳转的类，可以起的牛x的名字，XXCoreActionManager。

+ (BOOL)doActionForTarget:(NSDictionary *)target{    //根据你的app结构，来取得你当前的controller，由它来进行跳转    UIApplication *application = [UIApplication sharedApplication];    AppDelegate *myAppDelegate = (AppDelegate *)[application delegate];    UIViewController *viewController;    if ([myAppDelegate getTabbarSelectedView]) {        viewController = [myAppDelegate getTabbarSelectedView].visibleViewController;    }else {        return NO;    }    if([json[@"action"] isEqualToString:@"film_view"]){        MFMaterialListViewController *materialListVC = [[MFMaterialListViewController alloc] initWithNibName:@"MFMaterialListViewController" bundle:nil];        materialListVC.hidesBottomBarWhenPushed = YES;        materialListVC.filmId = json[@"data"][@"film_id"];        [viewController.navigationController pushViewController:materialListVC animated:YES];        return YES;    }else if([json[@"action"] isEqualToString:@"home"]){        [myAppDelegate getTabbar].selectedIndex = 0;        [viewController.navigationController popToRootViewControllerAnimated:YES];        return YES;    }    return NO;}

[XXCoreActionManager doActionForTarget:target];

• 针对头像、评论、转发等多处使用的子控件，可以把事件由自己接收，通过XXCoreActionManager来进行跳转。即做到了代码分离，使之成为真正独立的控件，便于复用。

implementation MFUserHeadButton-(void)awakeFromNib{    [self addTarget:self action:@selector(toUserDetail) forControlEvents:UIControlEventTouchUpInside];}- (void)toUserDetail{    NSDictionary *target = @{@"action":@"user",                           @"data":@{@"user_id":@(self.tag)}};    [XXCoreActionManager doActionForTarget:target];}

- (void)setDict:(NSDictionary *)dict {        objc_setAssociatedObject(self, dictKey, dict, OBJC_ASSOCIATION_RETAIN_NONATOMIC);}- (NSDictionary *)dict {        return objc_getAssociatedObject(self, dictKey);}

• 一个是智能知识库；
• 一个智能机器人。

1. 传统 call center的时代: 互联网尚未普及，电话客服客户等待时间长，客户服务人员压力大，工作重复内容多；
2. 到了PC网页客服时代，随着互联网的普及，网页客服的成本明显小于电话客服，客户服务人员工作量较小，客户满意度有所提高，但相应依然不能及时有效；
3. 当今，随着智能手机用户的快速增长，客户要求能够随时在移动端获取咨询服务。移动端客服的重要性将不断上升。移动客服时代随之到来。

1. 一类是工单客服，可以被视为移动客服1.0，基于工单方式和客服交互，技术实现简单，但无法做到实时交互，沟通效率低，用户体验差。
2. 另一类是轮询技术客服，可以被视为移动客服2.0，基于HTTP轮询技术，通过不断向服务器发送查询请求来准实时的收取消息。不能做到实时收取消息，流量和电量消耗高，APP在后台时无法接收消息，容易丢失客户。

• 环信移动客服实现了跨平台多渠道接入：支持 App、微信公众账号、微博、网页等，均可以快速统一接入客户服务后台管理。

• 其次，满足了开放性与自定义信息：这种新型的移动客服实现了代码开源、UI开源，还提供多套UI模版，便于与APP快速集成，平滑接入。同时第三方集成功能也很强大，可与第三方工单、知识库、CRM 系统等进行扩展集成。
• 第三，富媒体消息交互体验：移动客服平台提供了基于IM技术的类似微信体验的友好富媒体消息交互，不仅可以实时收发文字、表情，还可以即时收发图片、位置、实时语音、还可自定义消息，大大方便了与客户的沟通交流。
• 第四，精准客户画像功能：移动客服的IM沟通帮助企业辅助判断客户需求与诉求，通过自定义客户分类标签，客户再次访问时可获知客户的类型。并且还支持自定义会话小结，根据会话小结统计会话的分类，通过会话小结追踪客户诉求。通过轨迹分析功能，即通过发送客户访问页面的轨迹，判断客户意图，获取客户个性化细节，了解客户基础信息，分析客户行为，可以极大提高订单效率。
• 第五，“智能机器人+智能知识库”：作为一套智能化的客服系统，让企业建立基于业务的智能知识库，智能辅助归结业务信息和应答客户信息，历史常见问题系统梳理，提高客服效率。“智能机器人+智能知识库”组合目前可自动回复80%常见问题，随着智能知识库的不断训练，这一比例能够提高到90%。
• 第六、真正实现不丢订单：环信是中国乃至全球领先的即时通讯云服务提供商，上线1年来，已成为唯一一家经历了亿级长连接真实稳定运行的即时通讯云平台，中国主流的采用第三方即时通讯云服务的App几乎都是环信的客户，每日环信平台的消息量达到数亿条，有着即时通讯云领域亿级长连接的绝对垄断优势。环信基于IM长连接技术，帮助企业实现超线拉取排队会话，让等待时间过长或有订单需求的客户得到优先服务，提升客服效率，即使客户关闭会话，退出App，甚至关闭手机，基于IM长连接技术依然能找回客户会话，提升客服效率，不丢客户订单。同时，基于IM长连接技术，即使在断网或复杂网络切换时也依然能找回客户会话，不丢客户订单。
• 第七、实现了质检系统透明管理：移动客服自带实时监控系统，可实时监控当前所有会话，管理员在线质检，在线查看会话信息，还提供了历史会话查询、质检考核。通过实时与历史查看，可以统计出客服代表的接入量、在线时间及应答等待时间。

[root@localhost ~]# ip route show table all

10.1.1.0/24 dev eth0  proto kernel  scope link  src 10.1.1.247

10.1.2.0/24 dev eth1  proto kernel  scope link  src 10.1.2.239

169.254.0.0/16 dev eth0  scope link  metric 1002

169.254.0.0/16 dev eth1  scope link  metric 1003

default via 10.1.1.1 dev eth0 

 

[root@localhost ~]# ip rule show

0:  from all lookup local

32766:  from all lookup main

32767:  from all lookup default

$ cat /etc/iproute2/rt_tables

#

# reserved values

#

255    local

254    main

253    default

252    lan1

251    lan2

0    unspec

ip route flush table lan1

ip route add default via 10.1.1.1 dev eth0 src 10.1.1.247 table lan1

ip rule add from 10.1.1.247 table lan1

 

ip route flush table lan2

ip route add default via 10.1.2.1 dev eth1 src 10.1.2.239 table lan2

ip rule add from 10.1.2.239 table lan2

[root@localhost ~]# ip route show all

10.1.1.0/24 dev eth0  proto kernel  scope link  src 10.1.1.247

10.1.2.0/24 dev eth1  proto kernel  scope link  src 10.1.2.239

169.254.0.0/16 dev eth0  scope link  metric 1002

169.254.0.0/16 dev eth1  scope link  metric 1003

default via 10.1.1.1 dev eth0 

 

[root@localhost ~]# ip rule show

0:  from all lookup local

32764:  from 10.1.2.239 lookup lan2

32765:  from 10.1.1.247 lookup lan1

32766:  from all lookup main

32767:  from all lookup default

ip route flush table lan1

ip route add default via 10.1.1.1 dev eth0 src 10.1.1.247 table lan1

ip rule add from 10.1.1.247 table lan1

ip rule add from 10.1.1.247 to 10.1.1.0/24 table main

 

ip route flush table lan2

ip route add default via 10.1.2.1 dev eth1 src 10.1.2.239 table lan2

ip rule add from 10.1.2.239 table lan2

ip rule add from 10.1.2.239 to 10.1.2.0/24 table main

[root@localhost ~]# ip route show table all

default via 10.1.1.1 dev eth0  table lan1  src 10.1.1.247

10.1.1.0/24 dev eth0  proto kernel  scope link  src 10.1.1.247

10.1.2.0/24 dev eth1  proto kernel  scope link  src 10.1.2.239

169.254.0.0/16 dev eth0  scope link  metric 1002

169.254.0.0/16 dev eth1  scope link  metric 1003

default via 10.1.1.1 dev eth0

default via 10.1.2.1 dev eth1  table lan2  src 10.1.2.239 

 

[root@localhost ~]# ip rule show

0:    from all lookup local

32762:    from 10.1.2.239 to 10.1.2.0/24 lookup main

32763:    from 10.1.2.239 lookup lan2

32764:    from 10.1.1.247 to 10.1.1.0/24 lookup main

32765:    from 10.1.1.247 lookup lan1

32766:    from all lookup main

32767:    from all lookup default

upstream php-fpm {

server unix:/var/run/phpfpm.sock;

}

 

server {

listen 80;

server_name timo.piqiu.me;

 

root /opt/web/wordpress;

index index.php;

 

access_log logs/timo.piqiu.me.access.log proxy;

error_log logs/timo.piqiu.me.error.log;

 

location = /favicon.ico {

log_not_found off;

access_log off;

}

 

location = /robots.txt {

allow all;

log_not_found off;

access_log off;

}

 

location ~ /\.svn/* {

deny all;

}

 

location ~ /\.git/* {

deny all;

}

 

location /nginx_status {

stub_status on;

access_log off;

}

 

set $cache_uri $request_uri;

 

# POST requests and urls with a query string should always go to PHP

if ($request_method = POST) {

set $cache_uri 'null cache';

}

if ($query_string != "") {

set $cache_uri 'null cache';

}

 

# Don't cache uris containing the following segments

if ($request_uri ~* "(/wp-admin/|/xmlrpc.php|/wp-(app|cron|login|register|mail).php|wp-.*.php|/feed/|index.php|wp-comments-popup.php|wp-links-opml.php|wp-locations.php|sitemap(_index)?.xml|[a-z0-9_-]+-sitemap([0-9]+)?.xml)") {

set $cache_uri 'null cache';

}

 

# Don't use the cache for logged in users or recent commenters

if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_logged_in") {

set $cache_uri 'null cache';

}

 

# Use cached or actual file if they exists, otherwise pass request to WordPress

location / {

try_files /wp-content/cache/supercache/$http_host/$cache_uri/index.html $uri $uri/ /index.php ;

}

location ~ \.php$ {

try_files /wp-content/cache/supercache/$http_host/$cache_uri/index.html $uri $uri/ /index.php ;

fastcgi_pass php-fpm;

fastcgi_index index.php;

fastcgi_param SCRIPT_FILENAME /opt/web/wordpress$fastcgi_script_name;

fastcgi_intercept_errors on;

include fastcgi_params;

#

# fastcgi_cache cache_fastcgi;

#

# fastcgi_cache_valid 200 302 301 24h;

# fastcgi_cache_valid any 1m;

#

# fastcgi_cache_min_uses 1;

#

# fastcgi_cache_use_stale error timeout invalid_header http_500;

# fastcgi_cache_key $request_method://$host$request_uri;

}

 

# Cache static files for as long as possible

location ~* .(ogg|ogv|svg|svgz|eot|otf|woff|mp4|ttf|css|rss|atom|js|jpg|jpeg|gif|png|ico|zip|tgz|gz|rar|bz2|doc|xls|exe|ppt|tar|mid|midi|wav|bmp|rtf)$ {

expires max; log_not_found off; access_log off;

}

 

location ~ ^/(status|ping)$ {

include /opt/server/nginx/conf/fastcgi_params;

fastcgi_pass unix:/var/run/phpfpm.sock;

fastcgi_param SCRIPT_FILENAME $fastcgi_script_name;

allow 127.0.0.1;

deny all;

}

}

[12826] 01 Apr 16:54:37.675 # I/O error trying to sync with MASTER: connection lost

[12826] 01 Apr 16:54:38.555 * Connecting to MASTER 10.x.x.x:6379

[12826] 01 Apr 16:54:38.555 * MASTER <-> SLAVE sync started

[12826] 01 Apr 16:54:38.621 * Non blocking connect for SYNC fired the event.

[12826] 01 Apr 16:54:38.692 * Master replied to PING, replication can continue...

[12826] 01 Apr 16:54:45.229 * MASTER <-> SLAVE sync: receiving 390598473 bytes from master

client-output-buffer-limit slave 256mb 64mb 60

• The hard limit is a fixed limit that when reached will make Redis closing the client connection as soon as possible.
• The soft limit instead is a limit that depends on the time, for instance a soft limit of 32 megabytes per 10 seconds means that if the client has an output buffer bigger than 32 megabytes for, continuously, 10 seconds, the connection gets closed.

• Normal clients have a default limit of 0, that means, no limit at all, because most normal clients use blocking implementations sending a single command and waiting for the reply to be completely read before sending the next command, so it is always not desirable to close the connection in case of a normal client.
• Pub/Sub clients have a default hard limit of 32 megabytes and a soft limit of 8 megabytes per 60 seconds.
• Slaves have a default hard limit of 256 megabytes and a soft limit of 64 megabyte per 60 second.

  

  //当GCM需要谷歌账户(设备版本低于4.0.4时需要)  

    

    

  
      android:protectionLevel="signature" />  

    

           android:name="com.google.android.gms.gcm.GcmReceiver"  

           android:exported="true"  

           android:permission="com.google.android.c2dm.permission.SEND" >  

             

                 

                 

             

       

            android:name="com.example.MyGcmListenerService"  

            android:exported="false" >  

              

                  

              

          

  

public class MyGcmListenerService extends GcmListenerService {  

  

      @Override  

    public void onMessageReceived(String from, Bundle data) {  

        String message = data.getString("message");  

        /**  

         * Production applications would usually process the message here.  

         * Eg: - Syncing with server.  

         *     - Store message in local database.  

         *     - Update UI.  

         */  

  

        /**  

         * In some cases it may be useful to show a notification indicating to the user  

         * that a message was received.  

         */  

        sendNotification(message);  

    }  

    // [END receive_message]  

  

    /**  

     * Create and show a simple notification containing the received GCM message.  

     *  

     * @param message GCM message received.  

     */  

    private void sendNotification(String message) {  

        Intent intent = new Intent(this, MainActivity.class);  

        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);  

        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, intent,  

                PendingIntent.FLAG_ONE_SHOT);  

  

        Uri defaultSoundUri= RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);  

        NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this)  

                .setSmallIcon(R.drawable.ic_stat_ic_notification)  

                .setContentTitle("this is a new new GCM Message")  

                .setContentText(message)  

                .setAutoCancel(true)  

                .setSound(defaultSoundUri)  

                .setContentIntent(pendingIntent);  

  

        NotificationManager notificationManager =  

                (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);  

  

        notificationManager.notify(0 /* ID of notification */, notificationBuilder.build());  

    }  

}  


 

3.注册监听token改变的服务（在app中创建一个服务类继承InstanceIDListenerService类，本服务存在于新的Google play服务版本上）
 android:name="com.example.MyInstanceIDListenerService"  

            android:exported="false">  

              

                  

              

          

  

public class MyInstanceIDListenerService extends InstanceIDListenerService {  

  

       @Override  

    public void onTokenRefresh() {  

        // Fetch updated Instance ID token and notify our app's server of any changes (if applicable).  

    }  

}  


 

gcm通过注册的系统广播可以自行启动GcmListenerService类，所以不需要在app创建一个广播类



注册token



App发送 project number到GCM Server注册接收推送信息。 



GCM Server 向App返回token(token是GCM服务器自行生产的，能够保证某一终端设备上的某一个应用，很重要)。 

在设备上应该先判断是否安装了Google play 服务
int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);  

if (resultCode != ConnectionResult.SUCCESS) {  

    if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {  

        GooglePlayServicesUtil.getErrorDialog(resultCode, this, PLAY_SERVICES_RESOLUTION_REQUEST).show();//会提示错误对话框，其他错误信息可参考官网API  

    } else {  

        Log.i(TAG, "This device is not supported.”);  

    }  


 

 

Google play服务存在，那接下来就需要去注册token了，在上边创建项目得到的project number在这里就需要用它来注册token





	









	





 
InstanceID instanceID = InstanceID.getInstance(this);  

String token = instanceID.getToken(PROJECT_NUMBER,  

GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);  


 

对于旧版本还是要使用以下方式来注册token（用于Google play 服务7.5版本之前）
GoogleCloudMessaging.getInstance(Context).register(PROJECT_NUMBER);  


 

在自己的服务器端注册api key



App向我们自己服务器发送token(推送消息的时候要使用token，GCM服务器是使用token来确定某一终端设备上的某一个应用接收消息的，所以第三方服务器需要保存它，需要注意的是token很长，存数据库时需要注意字段长度) ，将我们在上边create new key 得到的apikey添加到自己的服务器端保存，我们的服务器向GCM Server发送消息,传递apikey和token ，GCM Server把消息推送给App 

最后注意一下，关于app卸载出现的问题，看一下官方的介绍





	







app会发生卸载过程并不能很快完成，卸载app需要花时间从GCM移除当前关联的token，这个过程就会出现发送消息是成功的，但是不能到达app客户端，在最后，token被移除了，服务器端发送的消息失败，得到一个NotRegistered错误，这个时候就应该在服务器端删除相对应的token																			        	收起阅读 »
								        											

  


    android:layout_width="fill_parent"  

    android:layout_height="45.0dip"  

    android:background="@drawable/bg_title_bar"  

    android:gravity="top" >  

  

    
        android:id="@+id/title_bar_menu_btn"  

        android:layout_width="wrap_content"  

        android:layout_height="wrap_content"  

        android:layout_centerVertical="true"  

        android:layout_marginLeft="3.0dip"  

        android:layout_marginRight="3.0dip"  

        android:layout_marginTop="3.0dip"  

        android:gravity="center"  

        android:src="@drawable/ic_top_bar_category" />  

  

    
        android:layout_width="wrap_content"  

        android:layout_height="fill_parent"  

        android:layout_toRightOf="@id/title_bar_menu_btn"  

        android:background="@drawable/ic_top_divider" />  

  

    
        android:id="@+id/title_bar_name"  

        android:layout_width="wrap_content"  

        android:layout_height="wrap_content"  

        android:layout_centerInParent="true"  

        android:ellipsize="end"  

        android:gravity="center"  

        android:paddingLeft="75.0dip"  

        android:paddingRight="75.0dip"  

        android:singleLine="true"  

        android:text="Java学习宝典"  

        android:textColor="#ffffff"  

        android:textSize="22sp" />  

  

  

这样就行了，

然后我们要给标题栏上的按钮添加事件，这个更加简单了：

在MainActivity.java（对应activity_main.xml）中，onCreate函数中添加：事件可以自己改，我这里是让它控制左右滑动的功能。

ImageView menuImg = (ImageView) findViewById(R.id.title_bar_menu_btn);  

        menuImg.setOnClickListener(new View.OnClickListener() {  

  

            @Override  

            public void onClick(View arg0) {  

                if (!menuIsShow)  

                    showMenu();  

                else {  

                    hideMenu();  

                }  

  

            }  

  

        });  

这样就可以了：

我们来看看效果

这就是效果了，很简单吧，想用直接把上面的布局复制过去就OK了！
 
作者：林炳文Evankaka 收起阅读 »

• 一是移动端的量大，一个APP同时在线的人数可能在数十上百万；
• 二是一旦APP打开，与客服之间的连接就是一直长期保持的关系。而在PC端，网页一旦关闭，与客服之间的对话就已经中断。无疑，移动客服后台数据中心所承载的压力和成本是要远高于传统客服方式的。刘俊彦表示，这也是移动客服市场的主要门槛之一。 

@property (strong, nonatomic) NSArray *someViews;  

• nullable — Think UIView?
• nonnull — Think UIView
• null_unspecified — Think UIView!

@property (strong, nonatomic, nonnull) NSArray *someViews; 

@property (strong, nonatomic, nonnull) NSArray *someViews;  

@interface NSDictionary (Lookup)  

- (nullable ObjectType)objectForKey:(KeyType)aKey;  

@end  

[self.someViews[0] addTarget:self action:selector(aMethod:) forControlEvents:UIControlEventTouchUpInside];  

@property (strong, nonatomic, nonnull) NSArray<__kindof UIView *> *someViews;  

• 一是市场巨大：这两年在环信平台上，我们见证了新兴移动互联网app的爆发式增长，有些客户已经开始准备IPO，更多的公司经过各轮融资得到了快速发展。20%+的app都有付费能力，另外，大量的传统企业，像国美，链家等也开始使用我们的saas 服务，市场”钱景”广阔。
• 第二个体会是过程刺激。心脏不好的没法做企业SaaS。尤其是像我们的IM 云服务和移动客服产品，都是和客户的业务系统紧耦合的，是他们服务的关键一环。对稳定性要求比人力资源评测，后台数据分析等服务要求高的多。从上线以来，用户每月增长100%造成的容量压力;PaaS 服务商的宕机;DDoS攻击;DNS 域名污染，甚至线上运维错误操作。

• 第一内部交流：再忙也要做每周的技术分享，而且要高质量的，充分准备的。这个对年轻工程师帮助很大;
• 第二外部交流。我们自己主办 技术沙龙meetup. 也鼓励技术人员多参加各种会议和线下活动，和同行交流，和比自己更优秀的人交流，这个有助于核心工程师的技术提高;这块其实一直有人提醒我，小心优秀的工程师被挖走。但帮助他们更优秀，在社区更认同是我的责任，如果留不来了，也是我工作中的不足了。
• 第三是梯队培养：对重点的苗子，要越级使用，给比较大的技术挑战和压力，同时由技术负责人对他重点给予相关的指导和帮助。对年轻工程师，我们允许失败，但不允许犯同一个错误。

• 第一是待遇。兄弟们没日没夜的跟你干几年，工资要above market rate。即便没时间花，但给家里有个交待。期权更要多给，公司如果能成功，主要原因是团队每天的拼搏和贡献的积累，而不是因为创始人或投资人。
• 第二是发展。员工在环信的这2，3年技术水平等能不能有比较大的发展，跟上甚至超过公司的发展速度。我们是要求技术团队每人都得有一个6个月的发展目标，根据此目标，我和 team lead 来具体看怎么安排相关工作，并经常给予指导。
• 第三是快乐。个人觉得最重要。团队成员每天能不能高兴的来上班，enjoy 工作中的各种挑战。另外，我一直尽量创造轻松幽默的工作氛围，team内部提倡简单直接的沟通方式。

• 最近腾讯云也推出了即时通讯产品，环信的产品和他们产品对比，有哪些不同?

• 请问一下没有KPI，那么你们怎么做绩效考核或者说激励的呢?

• 环信做为im平台，会切入移动办公类的工具或系统开发吗，类似阿里钉钉之类的。

• 基于Web的跨平台设计，让用户在任何地方都可以随时通过浏览器访问


• Web形态的产品要具有原生客户端的体验，如任务的拖拽等


• 具有高效的实时消息系统，每个团队成员在Worktile中所做的任何操作，都要实时在其他成员的客户端中自动刷新


• 服务要稳定，稳定压倒一切那么Worktile是如何做到这几点的？点击上面蓝色字体，有你想知道的。

• 基于Web的跨平台设计，让用户在任何地方都可以随时通过浏览器访问


• Web形态的产品要具有原生客户端的体验，如任务的拖拽等


• 具有高效的实时消息系统，每个团队成员在Worktile中所做的任何操作，都要实时在其他成员的客户端中自动刷新


• 服务要稳定，稳定压倒一切

     ng-class="{1:'task-completed-style'}[task.completed]">

    
     id="task_check_{{ task.tid }}"

       wt-click="js_complete_task($event, entry, task)">

        

    

    {{task.name}}

     
            class="slide-trigger"

              hide_action="true"

              ng-click="locator.openTask(task.pid, task.tid)">

     

(function () {

    'use strict';

    angular.module('wtApp', [

        'wt.project.ctrl',

        'wt.team.ctrl',

        'wt.task.ctrl',

        'wt.event.ctrl',

        'wt.post.ctrl',

        'wt.file.ctrl',

        'wt.page.ctrl',

        'wt.mail.ctrl'

    ]);

}());

taskListCtrl.$inject = ['$scope', '$stateParams', 

            '$rootScope', '$popbox', 

            '$location', '$timeout', 

            'bus', 'globalDataContext', 

            'locator'];

on_task_trash            : "on_task_trash",

on_task_complete         : "on_task_complete",

on_task_move             : "on_task_move",

on_task_update           : "on_task_update",

on_task_comment          : "on_task_comment",

on_task_badges_file      : "on_task_badges_file",

on_task_unarchived       : "on_task_unarchived",

on_task_badges_check     : "on_task_badges_check"

  class A

    def initialize name      @name = name    end

    def to_s

      @name

    end

  endputs A.new('hehe') # => hehe

function A(name){  this.name = name

}

A.prototype.toString = function(){  return this.name

}var a = new A('hehe')

console.log('object name is:' + new A ('hehe')) // => object name is: hehe

• 这里的怪怪的函数其实就是constructor,相当于ruby例子里的initialize


• 而prototype上的方法toString也就是类似class模板上的方法。

1: // var a = new A('hehe') =>2: var a = new Object();3: a.__proto__ = A.prototype; (proto)4: A.call(a, 'hehe');

a.toString === A.prototype.toString // truea.toLocalString === Object.prototype.toLocalString // truea.__proto__ === A.prototype // true

Function.__proto__ === Object.prototype// false

Function.__proto__ === Function.prototype//true

Function instanceof Function//true

Function.__proto__ === Function.prototypeFunction.__proto__.__proto__ === Object.prototype

Function.__proto__.__proto__ = nullFunction instanceof Object//false

Object.__proto__ === Function.prototype// true// 但是Firefox取不到Object.__proto__, 看来做了保护，必须要用// Object.getPrototypeOf(Object) === Function.prototype

a.constructor === A.prototype.constructor

A.prototype.constructor === A

A.prototype.constructor = nulla.constructor // => nulla instanceof A // true

class A{

  constructor(name) {    this.name= name

  }

  toString() {    return this.name

  }

}class B extends A {

  toString(){    return this.name + 'b'

  }

}

function _inherits(subClass, superClass) { 

    // 密}var A = (function () {    function A(name) {        this.name = name;

    }



    A.prototype.toString = function toString() {        return this.name;

    };    return A;

})();var B = (function (_A) {    function B() {        if (_A != null) {

            _A.apply(this, arguments);

        }

    }



    _inherits(B, _A);



    B.prototype.toString = function toString() {        return this.name + 'b';

    };    return B;

})(A);

var a= new A('A');var b= new B('B');

a.constructor === A &&

b.constructor === B &&

a instanceof A &&

b instanceof A &&

b instanceof B

• https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/instanceof


• 这里只是意思，但是如果真的改变 __proto__ 是非常低效的https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto


• http://www.ecma-international.org/ecma-262/6.0/#sec-additional-properties-of-the-object.prototype-object

NS_DURING  

2.    // Call a dangerous method or function that raises an exception:  

3.    [obj someRiskyMethod];  

4.NS_HANDLER  

5.    NSLog(@"Oh no!");  

6.    [anotherObj makeItRight];  

7.NS_ENDHANDLER 

[cpp] view plaincopy

1.- (void)someRiskyMethod  

2.{  

3.    [NSException raise:@"Kablam"  

4.                format:@"This method is not implemented yet. Do not call!"];  

5.}  

@try {  

2.    [obj someRiskyMethod];  

3.}  

4.@catch (SomeClass *exception) {  

5.    // Handle the error.  

6.    // Can use the exception object to gather information.  

7.}  

8.@catch (SomeOtherClass *exception) {  

9.    // ...  

10.}  

11.@catch (id allTheRest) {  

12.    // ...  

13.}  

14.@finally {  

15.    // Code that is executed whether an exception is thrown or not.  

16.    // Use for cleanup.  

17.}  

cpp] view plaincopy

1.// A local variable to store an error object if one comes back:  

2.var error: NSError?  

3.// success is a Bool:  

4.let success = someString.writeToURL(someURL,  

5.                                    atomically: true,  

6.                                    encoding: NSUTF8StringEncoding,  

7.                                    error: &error)  

8.if !success {  

9.    // Log information about the error:  

10.    println("Error writing to URL: \(error!)")  

11.}  

enum AwfulError: ErrorType {  

2.    case Bad  

3.    case Worse  

4.    case Terrible  

5.}  

func doDangerousStuff() throws -> SomeObject {  

2.    // If something bad happens throw the error:  

3.    throw AwfulError.Bad  

4.  

5.    // If something worse happens, throw another error:   

6.    throw AwfulError.Worse  

7.  

8.    // If something terrible happens, you know what to do:   

9.    throw AwfulError.Terrible  

10.  

11.    // If you made it here, you can return:  

12.    return SomeObject()  

13.}  

do {  

2.    let theResult = try obj.doDangerousStuff()  

3.}  

4.catch AwfulError.Bad {  

5.    // Deal with badness.  

6.}  

7.catch AwfulError.Worse {  

8.    // Deal with worseness.  

9.}  

10.catch AwfulError.Terrible {  

11.    // Deal with terribleness.  

12.}  

13.catch ErrorType {  

14.    // Unexpected error!  

15.}  

let theResult = try! obj.doDangerousStuff()  

convenience init?(contentsOfFile path: String,  

2.                  encoding enc: UInt,  

3.                  error error: NSErrorPointer)  

do {  

2.    let str = try NSString(contentsOfFile: "Foo.bar",  

3.                           encoding: NSUTF8StringEncoding)  

4.}  

5.catch let error as NSError {  

6.    print(error.localizedDescription)  

7.} 

// Some scope:  

2.{  

3.    // Get some resource.  

4.  

5.    defer {  

6.        // Release resource.  

7.    }  

8.  

9.    // Do things with the resource.  

10.    // Possibly return early if an error occurs.  

11.  

12.} // Deferred code is executed at the end of the scope.  

• 响应时间：由于网络速度的下降， 响应时间开始变长，同一个url的访问时间可能会成倍增长，增加用户的等待时间；


• 错误率：由于网络质量的下降，丢包错包概率成倍增长，由于请求的错误也会导致服务器端处理错误率的提高，可能会造成返回数据为空或者错误，致使用户增加使用成本。

• http响应时间

• http错误率

• 请求量（rpm）

• Data I/O

• 故障隔离：子服务出现故障不会影响全局，比如广告业务出现问题并不会让整个App不能使用，依然可以查看新鲜事等；


• 独立扩展：每一个被拆分出的子服务有着不同的访问压力，比如新鲜事的调用相比一些二级页面的用户资料要高很多，所以前者会被分配更多的Web 服务器；


• 独立部署：一个大服务的配置因功能过多会异常复杂，一旦被拆分就可根据不同的特性需求定制配置项，从而提高可管理性；


• 团队协作开发：开发者都有着自己精通的方向，从而提高开发效率；


• 抽象出数据访问：在后续进行数据层面（数据库、缓存）扩展时，可通过修改子服务的Data Service，实现对下层数据的透明。

• Master将改变记录到二进制日志（binary log）中（这些记录叫做二进制日志事件，binary log events）；


• Slave将Master的binary log events拷贝到它的中继日志（relay log）；


• Slave重做中继日志中的事件，将改变反映它自己的数据。

• 异地容灾：在复杂的网络环境下，机房可能会出现网络状况，导致一些比较关键性的业务的可用性降低，备份机房后可保证服务不会出现明显的长时间中断；


• 负载分摊：单独一个机房可能不足以支撑全部的请求，这时可以把一部分的请求压力分担到另一个机房；


• 加速区域访问：在国内网络环境下，南方和北方相互之间网络访问时有较高的延迟。通过做多机房部署实现加速区域用户的访问。

• 异地冷备份

• 异地多活

• 分析用户行为，理解你的业务，如社交、电商、视频；

• 电商的特点是定期举办大促销活动，届时会需要大量的计算资源、应用服务器来扛流量峰值，此时可利用云计算平台的弹性实现快速扩展业务，而在自己业务压力、促销来临时调用API接口，及AutoScaling扩展后端计算资源。视频业务有非常明显的流量高峰期和低峰期，流量高峰期通常是白天或者大家晚上下班回家那段时间，晚上2点到早上6点是流量非常低的时候，可利用云计算弹性优势，来调用API方式调整业务带宽资源，从而达到节省成本目的。


• 合理规划系统，预估系统容量，如 10w / 100w / 1000w PV（DAU）：不同的系统容量有可能对应不同架构的部署方式，找到最适合自己的那一个；


• 系统是可横向扩展的 scalable；


• 不遗余力地解决单点问题；


• 为出错而设计design for failure：App的后端架构在开发支出就要为可能出现的各种问题进行准备，比如异地备份等；


• 设计面向服务的架构，拆分子系统，API交互，异步处理；


• 构建无处不在的缓存：页面缓存、接口缓存、对象缓存、数据库缓存；


• 避免过度设计，好的系统架构不是设计出来的，而是进化而来的。

• 绕 X 轴


• 绕 Y 轴


• 绕 Z 轴

// some default config values.

    var defaults = {

        width: 1024,

        height: 768,

        maxScale: 1,

        minScale: 0,



        perspective: 1000,



        transitionDuration: 700

    };

var computeWindowScale = function ( config ) {

        var hScale = window.innerHeight / config.height,

            wScale = window.innerWidth / config.width,

            scale = hScale > wScale ? wScale : hScale;



        if (config.maxScale && scale > config.maxScale) {

            scale = config.maxScale;

        }



        if (config.minScale && scale < config.minScale) {

            scale = config.minScale;

        }



        return scale;

    };

• impress-disabled is added to body element by the impress.js script


• impress-enabled after init() function is called

• future class appears on steps that were not yet visited


• present class appears on currently visible step - it's different from active class as present class is added when transition finishes (step is entered)


• past class is added to already visited steps (when the step is left)

• impress-progress.js 显示 ppt 的进度条

• 硬件规划
• SSD选择
• BIOS设置

• Linux OS
• Ceph Configurations
• PG Number调整
• CRUSH Map
• 其他因素

• Processor

• 内存

• 网络规划

• Hyper-Threading(HT)

• 关闭节能

for CPUFREQ in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do [ -f $CPUFREQ ] || continue; echo -n performance > $CPUFREQ; done 

• NUMA

kernel /vmlinuz-2.6.32-504.12.2.el6.x86_64 ro root=UUID=870d47f8-0357-4a32-909f-74173a9f0633 rd_NO_LUKS rd_NO_LVM LANG=en_US.UTF-8 rd_NO_MD SYSFONT=latarcyrheb-sun16 crashkernel=auto  KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM   biosdevname=0 numa=off 

• Kernel pid max

echo 4194303 > /proc/sys/kernel/pid_max 

ifconfig eth0 mtu 9000 

echo "MTU=9000" | tee -a /etc/sysconfig/network-script/ifcfg-eth0 2./etc/init.d/networking restart 

cat /sys/block/sda/queue/read_ahead_kb 

echo "8192" > /sys/block/sda/queue/read_ahead_kb 

echo "vm.swappiness = 0" | tee -a /etc/sysctl.conf 

echo "deadline" > /sys/block/sd[x]/queue/scheduler 2.echo "noop" > /sys/block/sd[x]/queue/scheduler 

• 不在process和thread在不同的core上移动(更好的缓存利用)
• 减少NUMA的影响
• 网络和存储控制器影响 - 较小
• 通过限制cpuset来限制Linux调度域(不确定是不是重要但是是最佳实践)
• 如果开启了HT，可能会造成OSD在thread1上，KVM在thread2上，并且是同一个core。Core的延迟和性能取决于其他一个线程做什么。

Total PGs = (Total_number_of_OSD * 100) / max_replication_count 

ceph osd pool set volumes pg_num 512 

2.ceph osd pool set volumes pgp_num 512 

ceph osd perf 

osd fs_commit_latency(ms) fs_apply_latency(ms) 

2.  0                    14                   17 

3.  1                    14                   16 

4.  2                    10                   11 

5.  3                     4                    5 

6.  4                    13                   15 

7.  5                    17                   20 

8.  6                    15                   18 

9.  7                    14                   16 

10.  8                   299                  329 

1.[global] 

2.fsid = 059f27e8-a23f-4587-9033-3e3679d03b31 

3.mon_host = 10.10.20.102, 10.10.20.101, 10.10.20.100 

4.auth cluster required = cephx 

5.auth service required = cephx 

6.auth client required = cephx 

7.osd pool default size = 3 

8.osd pool default min size = 1 

9. 

10.public network = 10.10.20.0/24 

11.cluster network = 10.10.20.0/24 

12. 

13.max open files = 131072 

14. 

15.[mon] 

16.mon data = /var/lib/ceph/mon/ceph-$id 

17. 

18.[osd] 

19.osd data = /var/lib/ceph/osd/ceph-$id 

20.osd journal size = 20000 

21.osd mkfs type = xfs 

22.osd mkfs options xfs = -f 

23. 

24.filestore xattr use omap = true 

25.filestore min sync interval = 10 

26.filestore max sync interval = 15 

27.filestore queue max ops = 25000 

28.filestore queue max bytes = 10485760 

29.filestore queue committing max ops = 5000 

30.filestore queue committing max bytes = 10485760000 

31. 

32.journal max write bytes = 1073714824 

33.journal max write entries = 10000 

34.journal queue max ops = 50000 

35.journal queue max bytes = 10485760000 

36. 

37.osd max write size = 512 

38.osd client message size cap = 2147483648 

39.osd deep scrub stride = 131072 

40.osd op threads = 8 

41.osd disk threads = 4 

42.osd map cache size = 1024 

43.osd map cache bl size = 128 

44.osd mount options xfs = "rw,noexec,nodev,noatime,nodiratime,nobarrier" 

45.osd recovery op priority = 4 

46.osd recovery max active = 10 

47.osd max backfills = 4 

48. 

49.[client] 

50.rbd cache = true 

51.rbd cache size = 268435456 

52.rbd cache max dirty = 134217728 

53.rbd cache max dirty age = 5 

urls = [', ']

results = map(urllib2.urlopen, urls)

results = []

for url in urls:

results.append(urllib2.urlopen(url))

from multiprocessing import Pool

from multiprocessing.dummy import Pool as ThreadPool

pool = ThreadPool()

• 为Android NDK中导出的OpenGL、OpenSL和OpenMAX接口，提供Go语言的绑定（binding）。
• 从Java语言到Go语言的绑定生成器（binding generator）。如果我们有一个Go语言编写的软件包，那么这个生成器可以帮助Java代码调用它，所以游戏菜单界面就可以直接使用标准的SDK来编写了。
• 集成到Android Studio的编译系统中。

• 工作在网络的7层之上，可以针对http应用做一些分流的策略，比如针对域名、目录结构，它的正则规则比HAProxy更为强大和灵活，这也是它目前广泛流行的主要原因之一，Nginx单凭这点可利用的场合就远多于LVS了。
• Nginx对网络稳定性的依赖非常小，理论上能ping通就就能进行负载功能，这个也是它的优势之一；相反LVS对网络稳定性依赖比较大，这点用过Nginx的人都深有体会；
• Nginx安装和配置比较简单，测试起来比较方便，它基本能把错误用日志打印出来。LVS的配置、测试就要花比较长的时间了，LVS对网络依赖比较大。
• 可以承担高负载压力且稳定，在硬件不差的情况下一般能支撑几万次的并发量，负载度比LVS相对小些。
• Nginx可以通过端口检测到服务器内部的故障，比如根据服务器处理网页返回的状态码、超时等等，并且会把返回错误的请求重新提交到另一个节点，不过其中缺点就是不支持url来检测。比如用户正在上传一个文件，而处理该上传的节点刚好在上传过程中出现故障，Nginx会把上传切到另一台服务器重新处理，而LVS就直接断掉了，如果是上传一个很大的文件或者很重要的文件的话，用户可能会因此而不满。
• Nginx不仅仅是一款优秀的负载均衡器/反向代理软件，它同时也是功能强大的Web应用服务器。LNMP也是近几年非常流行的web架构，在高流量的环境中稳定性也很好。
• Nginx现在作为Web反向加速缓存越来越成熟了，速度比传统的Squid服务器更快，可以考虑用其作为反向代理加速器。
• Nginx可作为中层反向代理使用，这一层面Nginx基本上无对手，唯一可以对比Nginx的就只有lighttpd了，不过lighttpd目前还没有做到Nginx完全的功能，配置也不那么清晰易读，社区资料也远远没Nginx活跃。
• Nginx也可作为静态网页和图片服务器，这方面的性能也无对手。还有Nginx社区非常活跃，第三方模块也很多。

• Nginx仅能支持http、https和Email协议，这样就在适用范围上面小些，这个是它的缺点。
• 对后端服务器的健康检查，只支持通过端口来检测，不支持通过url来检测。不支持Session的直接保持，但能通过ip_hash来解决。

• 抗负载能力强，工作在网络4层之上，仅作分发之用，没有流量的产生，这个特点也决定了它在负载均衡软件里的性能最强的，对内存和cpu资源消耗比较低。
• 配置性比较低，这是一个缺点也是一个优点，因为没有可太多配置的东西，所以并不需要太多接触，大大减少了人为出错的几率。
• 工作稳定，因为其本身抗负载能力很强，自身有完整的双机热备方案，如LVS+Keepalived，不过我们在项目实施中用得最多的还是LVS/DR+Keepalived。
• 无流量，LVS只分发请求，而流量并不从它本身出去，这点保证了均衡器IO的性能不会收到大流量的影响。
• 应用范围比较广，因为LVS工作在4层，所以它几乎可以对所有应用做负载均衡，包括http、数据库、在线聊天室等等。

• 软件本身不支持正则表达式处理，不能做动静分离；而现在许多网站在这方面都有较强的需求，这个是Nginx/HAProxy+Keepalived的优势所在。
• 如果是网站应用比较庞大的话，LVS/DR+Keepalived实施起来就比较复杂了，特别后面有Windows Server的机器的话，如果实施及配置还有维护过程就比较复杂了，相对而言，Nginx/HAProxy+Keepalived就简单多了。

• HAProxy也是支持虚拟主机的。
• HAProxy的优点能够补充Nginx的一些缺点，比如支持Session的保持，Cookie的引导；同时支持通过获取指定的url来检测后端服务器的状态。
• HAProxy跟LVS类似，本身就只是一款负载均衡软件；单纯从效率上来讲HAProxy会比Nginx有更出色的负载均衡速度，在并发处理上也是优于Nginx的。
• HAProxy支持TCP协议的负载均衡转发，可以对MySQL读进行负载均衡，对后端的MySQL节点进行检测和负载均衡，大家可以用LVS+Keepalived对MySQL主从做负载均衡。
• 5、HAProxy负载均衡策略非常多，HAProxy的负载均衡算法现在具体有如下8种：

• 第一阶段：利用Nginx或HAProxy进行单点的负载均衡，这一阶段服务器规模刚脱离开单服务器、单数据库的模式，需要一定的负载均衡，但是仍然规模较小没有专业的维护团队来进行维护，也没有需要进行大规模的网站部署。这样利用Nginx或HAproxy就是第一选择，此时这些东西上手快， 配置容易，在七层之上利用HTTP协议就可以。这时是第一选择。
• 第二阶段：随着网络服务进一步扩大，这时单点的Nginx已经不能满足，这时使用LVS或者商用Array就是首要选择，Nginx此时就作为LVS或者Array的节点来使用，具体LVS或Array的是选择是根据公司规模和预算来选择，Array的应用交付功能非常强大，本人在某项目中使用过，性价比也远高于F5，商用首选！但是一般来说这阶段相关人才跟不上业务的提升，所以购买商业负载均衡已经成为了必经之路。关人才的能力以及数量也随之提升，这时无论从开发适合自身产品的定制，以及降低成本来讲开源的LVS，已经成为首选，这时LVS会成为主流。
• 第三阶段：这时网络服务已经成为主流产品，此时随着公司知名度也进一步扩展，相关人才的能力以及数量也随之提升，这时无论从开发适合自身产品的定制，以及降低成本来讲开源的LVS，已经成为首选，这时LVS会成为主流。最终形成比较理想的基本架构为：Array/LVS — Nginx/Haproxy — Squid/Varnish — AppServer。

• Go：一年前，我们预言 Go 在 6 -12 个月的时间内会成为前 20 的语言。在 1 月份的排行中 Go 成为了第 17 位，预言成真。现在 Go 是第 15 位，超越了 Haskell 和 Matlab。


• Erlang：这是并发方面开发者长期选择的一种语言。Erlang 之前从第 26 位升到第 25 位，这主要是两周前 Erlang 抛弃了之前的 MPL 协议，选择了 Apache 协议。


• Julia/Rust:：历史性原因，这两个语言的发展轨迹很相似。上一季度，Rust 向上跳了 8 位，Julia 向上跳了 3 位。此次排名 Julia 比之前上升了 2 位到第 52 位，Rust 向上跳了 2 位到第 48 位。继续保持观望！


• CoffeeScript:：2013 年 Q3 排名 17，之后排名 18，18，21，现在是 22。重回前 20 这不是不可能的，至少找到了立足点和稳定的地位，但是前景并不乐观，因其缺乏动力和竞争。


• Dart / Visual Basic： 这是经常被问到的两个语言。Visual Basic 现在跟 Clojure，Groovy 排名第 19，未来是否还会在前 20 还不是很明朗。Dart，有着 Google 血统，还有 JavaScript 方面的野心，还在稳定增长中，比 Google 的另一个语言 Go 稍稍落后那么一点点，现在是从第 34 位升到第 33 位。


• Swift：这个月的 排名因为某些原因有些小小的问题。在几方的要求下，苹果 WWDC 前，我们去看 Swift 是否从第 68 升至第 22 位。不幸的是，因为 Stack Overflow 页面结构的改变，数据抓取失败，所以只能手动查看，缩小了范围，Swift 直接在前 20 位以后，排名 21。

• 单位时间内传输的数据量，单位通常是每秒比特数，记作bps；
• 带宽反映了网络的传输能力，越大越好；

• 数据包丢失个数，等于“发送数据包数” － “接受数据包数”；
• 丢包反映了网络可靠性，越小越好；

• 数据包从发送开始到接收到该数据所耗费的时间，单位通常是毫秒；
• 时延反映了网络的速度，越小越好；

• 指时延的变化，即两个数据包时延的差值；
• 抖动反映了网络的稳定性，越小越好；

• 指接收到的数据包顺序和发送顺序不一致的次数；
• 乱序反映了网络的稳定性，越小越好；
• 当乱序比较严重时，丢包也会比较严重，所以一般都以丢包指标为主，忽略乱序指标；

$ping -s 1024 192.168.1.100

 

PING www.microsoft.com (23.42.217.205): 1024 data bytes

 

1032 bytes from 23.42.217.205: icmp_seq=0 ttl=49 time=83.883 ms

 

1032 bytes from 23.42.217.205: icmp_seq=1 ttl=49 time=77.958 ms

 

1032 bytes from 23.42.217.205: icmp_seq=2 ttl=49 time=80.053 ms

 

1032 bytes from 23.42.217.205: icmp_seq=3 ttl=49 time=78.244 ms

 

1032 bytes from 23.42.217.205: icmp_seq=4 ttl=49 time=77.937 ms

 

...

 

^C

 

--- 192.168.1.100 ping statistics ---

 

30 packets transmitted, 29 packets received, 3.3% packet loss

 

round-trip min/avg/max/stddev = 77.843/95.375/141.314/19.167 ms

$iperf -u -s -p 12345 -i 1 -w 1000000

------------------------------------------------------------

 

Server listening on UDP port 12345

 

Receiving 1470 byte datagrams

 

UDP buffer size: 977 KByte

 

------------------------------------------------------------

$ iperf -u -c 127.0.0.1 -p 12345 -i 1 -t 5 -b 16K -l 62

 

------------------------------------------------------------

 

Client connecting to 127.0.0.1, UDP port 12345

 

Sending 62 byte datagrams

 

UDP buffer size: 9.00 KByte (default)

 

------------------------------------------------------------

 

[ 4] local 127.0.0.1 port 59805 connected with 127.0.0.1 port 12345

 

[ ID] Interval Transfer Bandwidth

 

[ 4] 0.0- 1.0 sec 2.00 KBytes 16.4 Kbits/sec

 

[ 4] 1.0- 2.0 sec 1.94 KBytes 15.9 Kbits/sec

 

[ 4] 2.0- 3.0 sec 1.94 KBytes 15.9 Kbits/sec

 

[ 4] 3.0- 4.0 sec 1.94 KBytes 15.9 Kbits/sec

 

[ 4] 4.0- 5.0 sec 2.00 KBytes 16.4 Kbits/sec

 

[ 4] 0.0- 5.1 sec 9.87 KBytes 16.0 Kbits/sec

 

[ 4] Sent 163 datagrams

 

[ 4] Server Report:

 

[ 4] 0.0- 5.1 sec 9.87 KBytes 16.0 Kbits/sec 0.046 ms 0/ 163 (0%)

or(unsigned second = 0; second < test_seconds; second++)

 

{

 

for(unsigned ui = 0; ui < 8; ui++)

 

{

 

sendto 1024 bytes;

 

}

 

msleep(1000);

 

}

for(unsigned second = 0; second < test_seconds; second++)

 

{

 

unsigned ts_start = gettimestamp();

 

for(unsigned ui = 0; ui < 8; ui++)

 

{

 

sendto 1024 bytes;

 

}

 

unsigned elapsed = gettimestamp() - ts_start;

 

msleep(1000-elapsed);

 

}

uint64_t sent_bytes = 0;

 

unsigned kick_time = gettimestamp();

 

for(unsigned second = 0; second < test_seconds; second++) { sendto 1024 bytes; sent_bytes += 1024; unsigned elapsed = gettimestamp() - kick_time; unsigned normal = sent_bytes * 1000 * 8 / （64*1000）; if(normal > elapsed)

 

{

 

msleep(normal-elapsed);

 

}

 

}

刘俊彦：环信在2013年4月成立，2014年6月第一个产品”环信即时通讯云”正式上线。然后在今年4月份上线了移动客服产品。在过去的一年里面，环信做了三轮融资，分别是去年5月份的天使轮，去年8月份的A轮，和去年10月份的A+轮。截止到今年5月底，一共有23000款APP在使用环信即时通讯云SDK。环信的SDK覆盖了2.5亿的终端用户，环信即时通讯平台日活是千万级别，每天处理将近两亿条消息。这就是环信过去两年大概的情况。

刘俊彦：虽然移动客服是一种移动互联网时代的新产品，但其实也只是形式上的一个创新。基本上每一个APP的设置页面都会有一个“意见反馈”的功能。其实这个功能就是一个客服功能，只是受限于技术、资源等因素，需要以表单的形式来呈现，有的时候还需要用户选择类别、提交联系方式，很难做到实时更新。



最近这一年，随着移动电商、O2O，在线教育，在线旅游，互联网金融产品的发展，出现了很多形式的客服产品。比如：作为电商，做O2O一定要做售前、售中、售后。这个过程中就涉及到用户与商家的沟通。



常见的沟通形式有4种，第一种是在App里面提供一个按钮，用户点击该按钮直接跳转到QQ，然后通过QQ去完成与商家的交流。



第二种是通过链接跳转微信。第三种形式就是我们最开始提到的表单形式，这种形式是非实时的。



最新的一种形式是用即时通讯的方法来跟商家沟通。用户打开一个窗口，在该窗口可以发语音、图片、文字，可以跟商家进行实时互动，这种形式就类似与微信、旺旺。第四种形式是最受大家欢迎，受O2O的商家、电商、医疗、互联网金融认可度最高的的一种客服形式，这种形式非常有利于用户通过手机与商家进行沟通。

刘俊彦：用IM来做客服虽然很方便，但它的技术门槛比较高。第一需要你的服务器能够做到千万级、亿级的并发处理。移动客服是基于IM的长连接技术实现的。举个例子，如果某个App有100万日活用户，那么用户的手机和客服服务器之间就存在一百万条长连接。一些大型的App可能会有几百万、几千万的日活用户，那么提供服务的厂家就需要支持几百万、几千万的用户长连接。如果你的平台要支持上几百家厂商，那么平台就需要有支持几千万到几亿用户同时连接的能力。



第二需要做到不丢消息，并且每一条消息能够做到最实时的到达。即时通讯服务是帮助商家来进行销售的，用户可能是在三线城市，也可能是在四线城市，网络环境可能是2G、3G或4G。要做到任何情况下，只要有网络，消息一定能够即时到达是非常困难的。但如果你的平台做不到，就会给商家带来损失。拿电商来举例：一个消费者想买一样东西，发了一条咨询消息，但这个消息丢失了，那么就意味着这个单子丢了。这个用户可能是商家花了很多钱，从其它平台导流过来的，但是因为一条咨询没有即时收到，结果流失了，这样就给商家带来了损失。



环信对于移动客服的技术已经非常成熟，因为环信从去年6月1日正式上线，做的就是即时通讯云。我们在即时通讯云这一块已经做到了全国有2.3万家APP使用，有2.5亿用户，平台的日活用户是几千万。两年多的技术储备让我们敢保证绝对不丢消息，并且消息能够非常实时的到达。

刘俊彦：解决该问题要从技术与非技术两方面着手。非技术其实就只能靠烧钱来解决。我们系统上大概有50%的余量，超过50%的压力之后，就开始加服务器。这样能保证系统在不到50%冗余的情况下运行。当然这也意味着有50%的容量浪费，其实这个“浪费”是应付一些不可预料的波峰和波谷。单个APP的用户行为基本是固定的。社交类APP，大概在晚上十点半会产生波峰。而有一些企业办公类、教育类App是在白天产生波峰。我们为两万多家APP提供服务，综合起来整个波峰和波谷就会比较平均一些。



我们也采取了一些技术手段来解决该问题。现在有一些云服务平台提供秒级计算API。当到半夜两点钟，所有APP都进入波谷后，我们就会调用API释放掉一批服务器。但这样带来的经济效益也不高，因为秒级API走的是另外一套收费体系。

刘俊彦：环信的四位创始人有三位都是长期在开源社区工作的。而我从03年以后，基本上没有做过商业软件。所以开源精神已经深深植入到每一位创始人。



除了UI开源之外，我们还建了一个自己的开源社区。在过去的两年里，我们看到了一个很有意思的现象。很多人用环信来做社交，有单聊、群聊、匿名群聊等等各种玩法。但是归纳之后，大概可分为几十种。所以我们希望通过社区的力量，把这几十种常见的社交模块做出来，然后用开源的形式提供给大家。当用户想要做一款新的社交APP时，基于环信这样的底层云服务模块，有可能会节约几个月的时间。



有了上面的基础，我们就想走的更远一点。当你想做一款APP的时候，你可能用到一个朋友圈的功能，用到一个匿名的功能，我们希望这些功能也变成一个现成的模块，甚至整个APP都能够以开源的形式完整呈现。这样大家在开发一款APP的时候，就像是搭积木，选不同的积木模块，然后把他们拼起来。特别是对于创业者，可以把更多的时间用于提升用户体验。



最近这一个月我们开放了三个应用级别的模块：第一个是凡信，它是高仿微信的一款APP。凡信实现了单聊、群聊、朋友群等功能。这是我们社区里一个网友开发的，他完全无私的把服务器端和客服端代码开源出来。第二个是一个类似于陌陌的陌生人交友APP，功能主要是看附近的人，看到附近的人之后可以跟他聊天。第三个是我们面向企业的开源产品。上面提到的开源项目大家都可以到我们的社区下载，当然你也可以成为这些项目的贡献者，一起来推动这些产品往前走。

刘俊彦：到现在为止，环信的云服务都托管在国内最一流的云服务平台上。按照他们的星级来说，都是最顶尖的机房，可靠性、安全性都是有保证的。但为了给大家提供更可靠、更放心的云服务，“异地多活”已经列入了我们的开发计划，未来的几个月环信的“异地多活”就会正式上线。

刘俊彦：刚刚我提到过环信在过去一年里进行了三轮融资。我们目前其实正在做B轮融资，因为还在进行中，如果有更多的细节我会尽快告诉大家。



环信发展到现在已成规模，下一步我们会继续巩固环信在“即时通讯云”领域国内第一的位置，我们希望以最低的价格、最好的服务为做社交以及各种应用服务者提供即时通讯功能。其次我们在今年4月份上线了环信移动客服产品。移动客服是我们在即时通讯领域一个很大的扩展。在即时通讯领域有两种场景，一种是在APP里面用户和用户之间进行社交活动，另一种是用户与商家之间的聊天，也就是客服。我们一直认为任何一款APP，都需要即时通讯，那么要达到100%的覆盖，光做社交是无法实现的，所以我们要加上客服这一块。我们最终的愿景是用环信的力量和技术为每一款APP提供即时通讯功能。 

• 随着upload目录中文件越来越多，所在分区（例如D盘）如果出现容量不足，则很难扩容。只能停机后更换更大容量的存储设备，再将旧数据导入。


• 在部署新版本（部署新版本前通过需要备份）和日常备份website文件的时候，需要同时操作upload目录中的文件，如果考虑到访问量上升，后边部署由多台Web服务器组成的负载均衡集群，集群节点之间如果做好文件实时同步将是个难题。

• 优点：配置更加灵活，也能兼容老版本的上传和访问方式。

• 缺点：部署成由多台Web服务器组成的集群，各个Web服务器（集群节点）之间（虚拟目录下的）需要实时的去同步文件，由于同步效率和实时性的限制，很难保证某一时刻各节点上文件是完全一致的。

• 图片访问是很消耗服务器资源的（因为会涉及到操作系统的上下文切换和磁盘I/O操作）。分离出来后，Web/App服务器可以更专注发挥动态处理的能力。


• 独立存储，更方便做扩容、容灾和数据迁移。


• 浏览器（相同域名下的）并发策略限制，性能损失。


• 访问图片时，请求信息中总带cookie信息，也会造成性能损失。


• 方便做图片访问请求的负载均衡，方便应用各种缓存策略（HTTP Header、Proxy Cache等），也更加方便迁移到CDN。

• 旧图片数据怎么办？能否继续兼容旧图片路径访问规则？


• 独立的图片服务器上需要提供单独的上传写入的接口（服务API对外发布），安全问题如何保证？


• 同理，假如有多台独立图片服务器，是使用可扩展的共享存储方案，还是采用实时同步机制？

• 容量规划和扩展问题。


• 数据的同步、冗余和容灾。


• 硬件设备的成本和可靠性（是普通机械硬盘，还是SSD，或者更高端的存储设备和方案）。


• 文件系统的选择。根据文件特性（例如文件大小、读写比例等）选择是用ext3/4或者NFS/GFS/TFS这些开源的（分布式）文件系统。


• 图片的加速访问。采用商用CDN或者自建的代理缓存、web静态缓存架构。


• 旧图片路径和访问规则的兼容性，应用程序层面的可扩展，上传和访问的性能和安全性等。

public class MyLayout extends LinearLayout {  

02.  

03.    public MyLayout(Context context, AttributeSet attrs) {  

04.        super(context, attrs);  

05.    }  

06.  

07.}  

[html] view plaincopy

01.
02.    xmlns:tools="http://schemas.android.com/tools"  

03.    android:id="@+id/my_layout"  

04.    android:layout_width="match_parent"  

05.    android:layout_height="match_parent"  

06.    android:orientation="vertical" >  

07.  

08.    
09.        android:id="@+id/button1"  

10.        android:layout_width="match_parent"  

11.        android:layout_height="wrap_content"  

12.        android:text="Button1" />  

13.  

14.    
15.        android:id="@+id/button2"  

16.        android:layout_width="match_parent"  

17.        android:layout_height="wrap_content"  

18.        android:text="Button2" />  

19.  

20.  

myLayout.setOnTouchListener(new OnTouchListener() {  

02.    @Override  

03.    public boolean onTouch(View v, MotionEvent event) {  

04.        Log.d("TAG", "myLayout on touch");  

05.        return false;  

06.    }  

07.});  

08.button1.setOnClickListener(new OnClickListener() {  

09.    @Override  

10.    public void onClick(View v) {  

11.        Log.d("TAG", "You clicked button1");  

12.    }  

13.});  

14.button2.setOnClickListener(new OnClickListener() {  

15.    @Override  

16.    public void onClick(View v) {  

17.        Log.d("TAG", "You clicked button2");  

18.    }  

19.});  

/** 

02. * Implement this method to intercept all touch screen motion events.  This 

03. * allows you to watch events as they are dispatched to your children, and 

04. * take ownership of the current gesture at any point. 

05. * 

06. * 
Using this function takes some care, as it has a fairly complicated 

07. * interaction with {@link View#onTouchEvent(MotionEvent) 

08. * View.onTouchEvent(MotionEvent)}, and using it requires implementing 

09. * that method as well as this one in the correct way.  Events will be 

10. * received in the following order: 

11. * 

12. * 
 

13. * 
 You will receive the down event here. 

14. * 
 The down event will be handled either by a child of this view 

15. * group, or given to your own onTouchEvent() method to handle; this means 

16. * you should implement onTouchEvent() to return true, so you will 

17. * continue to see the rest of the gesture (instead of looking for 

18. * a parent view to handle it).  Also, by returning true from 

19. * onTouchEvent(), you will not receive any following 

20. * events in onInterceptTouchEvent() and all touch processing must 

21. * happen in onTouchEvent() like normal. 

22. * 
 For as long as you return false from this function, each following 

23. * event (up to and including the final up) will be delivered first here 

24. * and then to the target's onTouchEvent(). 

25. * 
 If you return true from here, you will not receive any 

26. * following events: the target view will receive the same event but 

27. * with the action {@link MotionEvent#ACTION_CANCEL}, and all further 

28. * events will be delivered to your onTouchEvent() method and no longer 

29. * appear here. 

30. * 
 

31. * 

32. * @param ev The motion event being dispatched down the hierarchy. 

33. * @return Return true to steal motion events from the children and have 

34. * them dispatched to this ViewGroup through onTouchEvent(). 

35. * The current target will receive an ACTION_CANCEL event, and no further 

36. * messages will be delivered here. 

37. */  

38.public boolean onInterceptTouchEvent(MotionEvent ev) {  

39.    return false;  

40.}  

public class MyLayout extends LinearLayout {  

02.  

03.    public MyLayout(Context context, AttributeSet attrs) {  

04.        super(context, attrs);  

05.    }  

06.      

07.    @Override  

08.    public boolean onInterceptTouchEvent(MotionEvent ev) {  

09.        return true;  

10.    }  

11.      

12.} 

public boolean dispatchTouchEvent(MotionEvent ev) {  

02.    final int action = ev.getAction();  

03.    final float xf = ev.getX();  

04.    final float yf = ev.getY();  

05.    final float scrolledXFloat = xf + mScrollX;  

06.    final float scrolledYFloat = yf + mScrollY;  

07.    final Rect frame = mTempRect;  

08.    boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;  

09.    if (action == MotionEvent.ACTION_DOWN) {  

10.        if (mMotionTarget != null) {  

11.            mMotionTarget = null;  

12.        }  

13.        if (disallowIntercept || !onInterceptTouchEvent(ev)) {  

14.            ev.setAction(MotionEvent.ACTION_DOWN);  

15.            final int scrolledXInt = (int) scrolledXFloat;  

16.            final int scrolledYInt = (int) scrolledYFloat;  

17.            final View[] children = mChildren;  

18.            final int count = mChildrenCount;  

19.            for (int i = count - 1; i >= 0; i--) {  

20.                final View child = children[i];  

21.                if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE  

22.                        || child.getAnimation() != null) {  

23.                    child.getHitRect(frame);  

24.                    if (frame.contains(scrolledXInt, scrolledYInt)) {  

25.                        final float xc = scrolledXFloat - child.mLeft;  

26.                        final float yc = scrolledYFloat - child.mTop;  

27.                        ev.setLocation(xc, yc);  

28.                        child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  

29.                        if (child.dispatchTouchEvent(ev))  {  

30.                            mMotionTarget = child;  

31.                            return true;  

32.                        }  

33.                    }  

34.                }  

35.            }  

36.        }  

37.    }  

38.    boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||  

39.            (action == MotionEvent.ACTION_CANCEL);  

40.    if (isUpOrCancel) {  

41.        mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;  

42.    }  

43.    final View target = mMotionTarget;  

44.    if (target == null) {  

45.        ev.setLocation(xf, yf);  

46.        if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {  

47.            ev.setAction(MotionEvent.ACTION_CANCEL);  

48.            mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  

49.        }  

50.        return super.dispatchTouchEvent(ev);  

51.    }  

52.    if (!disallowIntercept && onInterceptTouchEvent(ev)) {  

53.        final float xc = scrolledXFloat - (float) target.mLeft;  

54.        final float yc = scrolledYFloat - (float) target.mTop;  

55.        mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  

56.        ev.setAction(MotionEvent.ACTION_CANCEL);  

57.        ev.setLocation(xc, yc);  

58.        if (!target.dispatchTouchEvent(ev)) {  

59.        }  

60.        mMotionTarget = null;  

61.        return true;  

62.    }  

63.    if (isUpOrCancel) {  

64.        mMotionTarget = null;  

65.    }  

66.    final float xc = scrolledXFloat - (float) target.mLeft;  

67.    final float yc = scrolledYFloat - (float) target.mTop;  

68.    ev.setLocation(xc, yc);  

69.    if ((target.mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {  

70.        ev.setAction(MotionEvent.ACTION_CANCEL);  

71.        target.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  

72.        mMotionTarget = null;  

73.    }  

74.    return target.dispatchTouchEvent(ev);  

75.}  

•  Android事件分发是先传递到ViewGroup，再由ViewGroup传递到View的。


•  在ViewGroup中可以通过onInterceptTouchEvent方法对事件传递进行拦截，onInterceptTouchEvent方法返回true代表不允许事件继续向子View传递，返回false代表不对事件进行拦截，默认返回false。


• 子View中如果将传递的事件消费掉，ViewGroup中将无法接收到任何事件。


• 好了，Android事件分发机制完全解析到此全部结束，结合上下两篇，相信大家对事件分发的理解已经非常深刻了。