手机需要root过，不然没有权限拷贝apk到 /system/app 目录下面。

【步骤】

通过手机的【设置】--【关于手机】 查看当前系统的Android版本，例如我的手机是4.2.2。
在 http://wiki.rootzwiki.com/Google_Apps 中下载对应的服务包。

里面包含了很多的服务(system\app)app，我们只需要安装服务框架，登录服务，日历同步，通讯录同步，邮件同步即可。

拷贝到 \system\app 系统目录中。

【账户同步】

手机安装账户同步服务，首发于润物无声。

版本：Kubuntu 12.04
下载地址：http://www.kubuntu.org/getkubuntu/download-lts

【更新源(主要是下载速度的因素)】
deb http://mirrors.163.com/ubuntu/ precise main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ precise-security main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ precise-updates main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ precise-proposed main restricted universe multiverse
deb http://mirrors.163.com/ubuntu/ precise-backports main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ precise main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ precise-security main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ precise-updates main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ precise-proposed main restricted universe multiverse
deb-src http://mirrors.163.com/ubuntu/ precise-backports main restricted universe multiverse

# Remastersys Precise
deb http://www.remastersys.com/ubuntu precise main

【添加公钥】
wget -O - http://www.remastersys.com/ubuntu/remastersys.gpg.key | sudo apt-key add -

【安装 remastersys】
sudo apt-get update; sudo apt-get install remastersys

【测试文件 (careytest/test.test)】

• /home 目录，存放用户相关配置信息
• /etc 目录，存放全局配置信息
• /usr/bin/ 目录，存放安装文件
• /usr/lib/ 目录，存放库文件
• /var/spool/ 目录，存放运行相关文件

【采用 backup 方式备份全盘资料】
sudo remastersys backup

【ISO 镜像文件测试】

• live 模式测试，文件全部存在，内容一致
• install 安装测试，文件全部都在，内容一致，

注：在安装过程中自己创建的用户被丢弃

【ISC* 镜像文件测试】

• 测试通过

【总结】

• 如果是GNOME的主题，采用原生Ubuntu系统
• 如果是KDE的主题，采用原生KUbuntu系统

【参考资料】

• Creating Custom Kubuntu Using Remastersys:http://www.youtube.com/watch?v=wAvZr5z6Y-Q
• http://www.psychocats.net/ubuntu/remastersys
• 《 Remaster your system with Remastersys – tobrunet.ch Techblog》
• 《 Free Imaging software - CloneZilla & PartImage - Tutorial》

Ubuntu 制作一键安装盘（四），首发于润物无声。

注意：经过测试 remastersys 不能很好的支持GNOME发行版安装的KDE的桌面环境。

【安装KDE桌面环境】

1. sudo apt-get install kubuntu-desktop kde-standard
2. 简体中文支持：sudo apt-get install language-pack-kde-zh-hans language-pack-kde-zh-hant

【步骤】

• 制作发布安装盘 sudo remastersys dist
• live 模式测试, 版本 Ubuntu 12.04 KDE 32位

结果：进入KDE登录界面，因为custom账户没有密码，无法登录进去系统。

• live 模式测试, 版本 Ubuntu 12.04 KDE 64位

结果：可以进入GNOME主题系统，但是因为缺少/var/spool/isc* 工作目录，后台测试程序不完整。

考虑解决方案(isc* 为测试程序，工作目录在/var/spool/isc*)：
1. 修改 /usr/bin/remastersys 脚本文件，加入自己的处理，例如拷贝必要的文件

log_msg "Copying iscxxx files"
service iscxxx stop &> /dev/null
cp -rf /var/spool/isc* $WORKDIR/dummysys/var/spool/ &> /dev/null


2. sudo remastersys dist

结果2：可以进入GNOME主题系统，前后台程序运行正常。

• install 模式测试，无法进行系统的安装，没有安装过程，直接进入live模式

Ubuntu 制作一键安装盘（三），首发于润物无声。

【步骤】

• 修改源 /etc/apt/sources.list ，加入

# Remastersys Precise
deb http://www.remastersys.com/ubuntu precise main

• 安装RemasterSys，sudo apt-get update; sudo apt-get install remastersys，

如果出现GPG错误，请参照文章最后[错误解决]。
错误解决的另一种方法, Add repository key:
wget -O - http://www.remastersys.com/ubuntu/remastersys.gpg.key | sudo apt-key add -

• 进行备份
• • sudo remastersys dist cdfs

• • sudo remastersys dist iso custom.iso，生成 iso文件，大约 1.2GB

• • 拷贝出来 sudo cp /home/remastersys/remastersys/custom.iso /media/sf_vmshare/
• 新建虚拟机进行测试，运行 live 模式，guest账户登录，测试程序可以正常运行，测试通过

• 系统安装测试，测试通过

• 可选："sudo remastersys dist" 方式 live 光盘测试,测试通过

注：
更简便的方法可以采用 sudo remastersys backup，它可以同时备份用户账号信息。
采用 sudo remastersys dist，上面两步的合集。

【使用帮助】

【参考资料】

• 官网：http://www.remastersys.com/
• 百科Remastersys: http://baike.baidu.com/view/3051607.htm
• http://wiki.ubuntu.org.cn/Remastersys

【错误解决】

在安装更新时，运行命令行sudo apt-get update 或者运行更新管理器的时候，出现:

W: GPG 错误：http://ppa.launchpad.net precise Release: 由于没有公钥，无法验证下列签名： NO_PUBKEY EAA903E3A2F4C039错误，

解决方法：

在终端中运行：sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys EAA903E3A2F4C039 即可。

示例：

Ubuntu 制作一键安装盘（二），首发于润物无声。

注意：利用如下方法可以正常做出安装盘，但是安装过程中会出现错误，另外运行live cd的时候也会出现如下low graphic的问题，暂时无解，第一次尝试失败。

【步骤】

• 下载软件 relinux，https://launchpad.net/relinux，例如 relinux_0.4a1-5_i386.deb
• 安装 sudo dpkg -i relinux_0.4a1-5_i386.deb
• 依赖错误修复 sudo apt-get install -f
• 语言环境（简体中文）设定 echo $LANG; export LANG='zh_CN.UTF-8'; echo $LANG
• 制作镜像 sudo relinux, 暂时保留默认设定

• 查看 iso 文件，大小 2.0GB

zhours@zhours-VirtualBox:~/relinux$ ll /home/relinux/
总用量 1923372
drwxr-xr-x  4 root root       4096  5月 12 15:09 ./
drwxr-xr-x  4 root root       4096  5月 12 14:31 ../
-rw-r--r--  1 root root 1969508352  5月 12 15:09 custom.iso
-rw-r--r--  1 root root         47  5月 12 15:11 custom.iso.md5
drwxr-xr-x  6 root root       4096  5月 12 15:05 .ISO_STRUCTURE/
drwxr-xr-x 12 root root       4096  5月 12 14:31 .TMPSYS/
zhours@zhours-VirtualBox:~/relinux$
【参考资料】

• 官方：https://launchpad.net/relinux
• 视频：http://www.youtube.com/watch?v=3q6mibDs4Fo
• 制作发布包《 Creating Your Own Distributable Ubuntu DVD (Relinux) | HowtoForge - Linux Howtos and Tutorials》

Ubuntu 制作一键安装盘（一），首发于润物无声。

• 所需工具：Cyberduck
• 配置

服务器： auth.sinas3.com
端口：443
用户名：应用AccessKey
密码：应用SecretKey

【上传到七牛】

• 所需工具：qiniu-devtools-windows_386 [qrsync.exe]
• 配置, 新建 conf.json 文件

access_key： 应用AccessKey
secret_key：应用SecretKey
bucket：bucket 名称
sync_dir：本地同步文件夹

• 执行 qrsync.exe conf.json 即可

【外链切换】

• 原外链地址：

http://carey-wordpress.stor.sinaapp.com/uploads/2011/06/The-Moon-150x150.jpg

• 新外链地址：

http://carey.u.qiniudn.com/uploads/2011/06/The-Moon-150x150.jpg

【数据库相关】
1. 查询包含外链的相关文章
SELECT * FROM  `wp_posts` WHERE post_content LIKE  '%http://carey-wordpress.stor.sinaapp.com/%'

2. 指定文章替换
UPDATE wp_posts SET post_content = replace(post_content, 'http://carey-wordpress.stor.sinaapp.com/', 'http://carey.u.qiniudn.com/') WHERE ID=24

3. 全局替换
UPDATE wp_posts SET post_content = replace(post_content, 'http://carey-wordpress.stor.sinaapp.com/', 'http://carey.u.qiniudn.com/')

【资料相关】

• SAE 地址：http://sae.sina.com.cn/
• SAE SVN 地址：https://svn.sinaapp.com/carey
• 七牛官方：https://portal.qiniu.com/

迁移博客图片资源从SAE到七牛，首发于润物无声。

The following is an adapted excerpt from Getting Started with Raspberry Pi. I especially like this section of the book because it shows off one of the strengths of the Pi: its ability to combine modern web frameworks with hardware and electronics.

Not only can you use the Raspberry Pi to get data from servers via the internet, but your Pi can also act as a server itself. There are many different web servers that you can install on the Raspberry Pi. Traditional web servers, like Apache or lighttpd, serve the files from your board to clients. Most of the time, servers like these are sending HTML files and images to make web pages, but they can also serve sound, video, executable programs, and much more.

However, there's a new breed of tools that extend programming languages like Python, Ruby, and JavaScript to create web servers that dynamically generate the HTML when they receive HTTP requests from a web browser. This is a great way to trigger physical events, store data, or check the value of a sensor remotely via a web browser. You can even create your own JSON API for an electronics project!

Flask Basics

We're going to use a Python web framework called Flask to turn the Raspberry Pi into a dynamic web server. While there's a lot you can do with Flask "out of the box," it also supports many different extensions for doing things such as user authentication, generating forms, and using databases. You also have access to the wide variety of standard Python libraries that are available to you.

In order to install Flask, you'll need to have pip installed. If you haven't already installed pip, it's easy to do:

pi@raspberrypi ~ $ sudo apt-get install python-pip

After pip is installed, you can use it to install Flask and its dependencies:

pi@raspberrypi ~ $ sudo pip install flask

To test the installation, create a new file called hello-flask.py with the code from below.

hello-flask.py

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=80, debug=True)

Here's a breakdown of each line of code:

from flask import Flask

Load the Flask module into your Python script

app = Flask(__name__)

Create a Flask object called app

@app.route("/")
    def hello():

Run the code below this function when someone accesses the root URL of the server

return "Hello World!"

Send the text "Hello World!" to the client's web browser

if __name__ == "__main__":

If this script was run directly from the command line

app.run(host='0.0.0.0', port=80, debug=True)

Have the server listen on port 80 and report any errors.

NOTE: Before you run the script, you need to know your Raspberry Pi's IP address. You can run ifconfig to find it. An alternative is to install avahi-daemon (run sudo apt-get install avahi-daemon from the command line). This lets you access the Pi on your local network through the address http://raspberrypi.local. If you're accessing the Raspberry Pi web server from a Windows machine, you may need to put Bonjour Services on it for this to work.

Now you're ready to run the server, which you'll have to do as root:

pi@raspberrypi ~ $ sudo python hello-flask.py
 * Running on http://0.0.0.0:80/
 * Restarting with reloader

From another computer on the same network as the Raspberry Pi, type your Raspberry Pi's IP address into a web browser. If your browser displays "Hello World!", you know you've got it configured correctly. You may also notice that a few lines appear in the terminal of the Raspberry Pi:

10.0.1.100 - - [19/Nov/2012 00:31:31] "GET / HTTP/1.1" 200 -
10.0.1.100 - - [19/Nov/2012 00:31:31] "GET /favicon.ico HTTP/1.1" 404 -

The first line shows that the web browser requested the root URL and our server returned HTTP status code 200 for "OK." The second line is a request that many web browsers send automatically to get a small icon called a favicon to display next to the URL in the browser's address bar. Our server doesn't have a favicon.ico file, so it returned HTTP status code 404 to indicate that the URL was not found.

Templates

If you want to send the browser a site formatted in proper HTML, it doesn't make a lot of sense to put all the HTML into your Python script. Flask uses a template engine called Jinja2 so that you can use separate HTML files with placeholders for spots where you want dynamic data to be inserted.

If you've still got hello-flask.py running, press Control-C to kill it.

To make a template, create a new file called hello-template.py with the code from below. In the same directory with hello-template.py, create a subdirectory called templates. In thetemplates subdirectory, create a file called main.html and insert the code from below. Anything in double curly braces within the HTML template is interpreted as a variable that would be passed to it from the Python script via the render_template function.

hello-template.py

from flask import Flask, render_template
import datetime
app = Flask(__name__)

@app.route("/")
def hello():
   now = datetime.datetime.now()
   timeString = now.strftime("%Y-%m-%d %H:%M")
   templateData = {
      'title' : 'HELLO!',
      'time': timeString
      }
   return render_template('main.html', **templateData)

if __name__ == "__main__":
   app.run(host='0.0.0.0', port=80, debug=True)

Let's take a look at some of the important lines of code.

now = datetime.datetime.now()

Get the current time and store it in the object now

timeString = now.strftime("%Y-%m-%d %H:%M")

Create a formatted string using the date and time from the now object

templateData = {
   'title' : 'HELLO!',
   'time': timeString
   }

Create a dictionary of variables (a set of keys, such as title that are associated with values, such as HELLO!) to pass into the template

return render_template('main.html', **templateData)

Return the main.html template to the web browser using the variables in the templateDatadictionary

main.html

<!DOCTYPE html>
   <head>
      <title>{{ title }}</title>
   </head>

   <body>
      <h1>Hello, World!</h1>
      <h2>The date and time on the server is: {{ time }}</h2>
   </body>
</html>

In main.html, any time you see a word within double curly braces, it'll be replaced with the matching key's value from the templateData dictionary in hello-template.py.

Now, when you run hello-template.py (as before, you need to use sudo to run it) and pull up your Raspberry Pi's address in your web browser, you should see a formatted HTML page with the title "HELLO!" and the Raspberry Pi's current date and time.

NOTE: While it's dependent on how your network is set up, it's unlikely that this page is accessible from outside your local network via the Internet. If you'd like to make the page available from outside your local network, you'll need to configure your router for port forwarding. Refer to your router's documentation for more information about how to do this.

Connecting the Web to the Real World

You can use Flask with other Python libraries to bring additional functionality to your site. For example, with the RPi.GPIO Python module you can create a website that interfaces with the physical world. To try it out, hook up a three buttons or switches to pins 23, 24, and 25 as shown in this graphic:

The following code expands the functionality of hello-template.py, so copy it to a new file called hello-gpio.py. Add the RPi.GPIO module and a new route for reading the buttons, as I've done in the code below. The new route will take a variable from the requested URL and use that to determine which pin to read.

hello-gpio.py

from flask import Flask, render_template
import datetime
import RPi.GPIO as GPIO
app = Flask(__name__)

GPIO.setmode(GPIO.BCM)

@app.route("/")
def hello():
   now = datetime.datetime.now()
   timeString = now.strftime("%Y-%m-%d %H:%M")
   templateData = {
      'title' : 'HELLO!',
      'time': timeString
      }
   return render_template('main.html', **templateData)

@app.route("/readPin/<pin>")
def readPin(pin):
   try:
      GPIO.setup(int(pin), GPIO.IN)
      if GPIO.input(int(pin)) == True:
         response = "Pin number " + pin + " is high!"
      else:
         response = "Pin number " + pin + " is low!"
   except:
      response = "There was an error reading pin " + pin + "."

   templateData = {
      'title' : 'Status of Pin' + pin,
      'response' : response
      }

   return render_template('pin.html', **templateData)

if __name__ == "__main__":
   app.run(host='0.0.0.0', port=80, debug=True)

Here are the highlights:

@app.route("/readPin/<pin>")

Add a dynamic route with pin number as a variable.

   try:
      GPIO.setup(int(pin), GPIO.IN)
      if GPIO.input(int(pin)) == True:
         response = "Pin number " + pin + " is high!"
      else:
         response = "Pin number " + pin + " is low!"
   except:
      response = "There was an error reading pin " + pin + "."

If the code indented below try raises an exception (that is, there's an error), run the code in the except block.

GPIO.setup(int(pin), GPIO.IN)

Take the pin number from the URL, convert it into an integer and set it as an input

if GPIO.input(int(pin)) == True:
    response = "Pin number " + pin + " is high!"

If the pin is high, set the response text to say that it's high

else:
    response = "Pin number " + pin + " is low!"

Otherwise, set the response text to say that it's low

except:
    response = "There was an error reading pin " + pin + "."

If there was an error reading the pin, set the response to indicate that

You'll also need to create a new template called pin.html. It's not very different from main.html, so you may want to copy main.html to pin.html and make the appropriate changes as shown

pin.html

<!DOCTYPE html>
   <head>
      <title>{{ title }}</title>
   </head>

   <body>
      <h1>Pin Status</h1>
      <h2>{{ response }}</h2>
   </body>
</html>

With hello-gpio.py running, when you point your web browser to your Raspberry Pi's IP address, you should see the standard "Hello World!" page we created before. But add/readPin/24 to the end of the URL, so that it looks something likehttp://10.0.1.103/readPin/24. A page should display showing that the pin is being read as low. Now hold down the button connected to pin 24 and refresh the page; it should now show up as high!

Try the other buttons as well by changing the URL. The great part about this code is that we only had to write the function to read the pin once and create the HTML page once, but it's almost as though there are separate webpages for each of the pins!

Project: WebLamp

In chapter 7 of Getting Started with Raspberry Pi, Shawn and I show you how to use Raspberry Pi as a simple AC outlet timer using the Linux job scheduler, cron. Now that you know how to use Python and Flask, you can now control the state of a lamp over the web. This basic project is simply a starting point for creating Internet-connected devices with the Raspberry Pi.

And just like how the previous Flask example showed how you can have the same code work on multiple pins, you'll set up this project so that if you want to control more devices in the future, it's easy to add.

Connect a Power Switch Tail II to pin 25 of the Raspberry Pi, as shown in the illustration below. If you don't have a Power Switch Tail, you can connect an LED to the pin to try this out for now.

If you have another PowerSwitch Tail II relay, connect it to pin 24 to control a second AC device. Otherwise, just connect an LED to pin 24. We're simply using it to demonstrate how multiple devices can be controlled with the same code.

Create a new directory in your home directory called WebLamp.

In WebLamp, create a file called weblamp.py and put in the code from below:

weblamp.py

import RPi.GPIO as GPIO
from flask import Flask, render_template, request
app = Flask(__name__)

GPIO.setmode(GPIO.BCM)

# Create a dictionary called pins to store the pin number, name, and pin state:
pins = {
   24 : {'name' : 'coffee maker', 'state' : GPIO.LOW},
   25 : {'name' : 'lamp', 'state' : GPIO.LOW}
   }

# Set each pin as an output and make it low:
for pin in pins:
   GPIO.setup(pin, GPIO.OUT)
   GPIO.output(pin, GPIO.LOW)

@app.route("/")
def main():
   # For each pin, read the pin state and store it in the pins dictionary:
   for pin in pins:
      pins[pin]['state'] = GPIO.input(pin)
   # Put the pin dictionary into the template data dictionary:
   templateData = {
      'pins' : pins
      }
   # Pass the template data into the template main.html and return it to the user
   return render_template('main.html', **templateData)

# The function below is executed when someone requests a URL with the pin number and action in it:
@app.route("/<changePin>/<action>")
def action(changePin, action):
   # Convert the pin from the URL into an integer:
   changePin = int(changePin)
   # Get the device name for the pin being changed:
   deviceName = pins[changePin]['name']
   # If the action part of the URL is "on," execute the code indented below:
   if action == "on":
      # Set the pin high:
      GPIO.output(changePin, GPIO.HIGH)
      # Save the status message to be passed into the template:
      message = "Turned " + deviceName + " on."
   if action == "off":
      GPIO.output(changePin, GPIO.LOW)
      message = "Turned " + deviceName + " off."
   if action == "toggle":
      # Read the pin and set it to whatever it isn't (that is, toggle it):
      GPIO.output(changePin, not GPIO.input(changePin))
      message = "Toggled " + deviceName + "."

   # For each pin, read the pin state and store it in the pins dictionary:
   for pin in pins:
      pins[pin]['state'] = GPIO.input(pin)

   # Along with the pin dictionary, put the message into the template data dictionary:
   templateData = {
      'message' : message,
      'pins' : pins
   }

   return render_template('main.html', **templateData)

if __name__ == "__main__":
   app.run(host='0.0.0.0', port=80, debug=True)

Since there's a lot going on in this code, I've placed on the explanations inline, as comments.

Create a new directory within WebLamp called templates.

Inside templates, create the file main.html:

main.html

<!DOCTYPE html>
<head>
   <title>Current Status</title>
</head>

<body>
   <h1>Device Listing and Status</h1>

   {% for pin in pins %}
   <p>The {{ pins[pin].name }}
   {% if pins[pin].state == true %}
      is currently on (<a href="/{{pin}}/off">turn off</a>)
   {% else %}
      is currently off (<a href="/{{pin}}/on">turn on</a>)
   {% endif %}
   </p>
   {% endfor %}

   {% if message %}
   <h2>{{ message }}</h2>
   {% endif %}

</body>
</html>

There are two templating concepts being illustrated in this file. First:

{% for pin in pins %}
<p>The {{ pins[pin].name }}
{% if pins[pin].state == true %}
   is currently on (<a href="/{{pin}}/off">turn off</a>)
{% else %}
   is currently off (<a href="/{{pin}}/on">turn on</a>)
{% endif %}
</p>
{% endfor %}

This sets up a for loop to cycle through each pin, print its name and its state. It then gives the option to change its state, based on its current state. Second:

   {% if message %}
   <h2>{{ message }}</h2>
   {% endif %}

This if statement will print a message passed from your Python script if there's a message set (that is, a change happened).

In terminal, navigate to the WebLamp directory and start the server (be sure to use Control-C to kill any other Flask server you have running first):

pi@raspberrypi ~/WebLamp $ sudo python weblamp.py

The best part about writing the code in this way is that you can very easily add as many devices that the hardware will support. Simply add the information about the device to the pins dictionary. When you restart the server, the new device will appear in the status list and its control URLs will work automatically.

There's another great feature built in: if you want to be able to flip the switch on a device with a single tap on your phone, you can create a bookmark to the addresshttp://ipaddress/pin/toggle. That URL will check the pin's current state and switch it.

For more information about using Raspberry Pi, check out Getting Started with Raspberry Pi.

文章节选：http://mattrichardson.com/Raspberry-Pi-Flask/

搭建基于Flask框架的树莓派服务器，首发于润物无声。

Pushing data has a number of benefits such as increased battery life and decreased server load. GCM is free to use and has no quotas, so it is a perfect candidate to handle the heavy lifting required for data updates.

There are two types of messages you can push with GCM: Send-to-sync and message with payload. A send-to-sync is basically a tickle, telling your app to sync with the server while a message with payload lets you send data in the push message (up to 4kb). Here’s a simple, full stack example that will help highlight how to get each of these types of push messages integrated with your app.

The app will take either a push message with a payload that updates the time that is saved on the device or a send to sync message that triggers the app to sync the time with the server. This was created using the “Generate App Engine Backend” feature of Android Studio. The Android developers blog has a tutorial on this. If you already have a backend setup, the GCM setup instructions for an existing server can be found here.

The source for this example is up on GitHub.

Create a new endpoint

Wizard generated files Message.java and MessageEndpoint.java in PushDontPoll-AppEngine were deleted, along with the messageendpoint package in PushDontPoll-endpoints. In lieu of this, DateEndpoint.java was created in PushDontPoll-AppEngine. This class makes an endpoint at /_ah/api/dateendpoint/v1/currentdate that provides the current time in JSON:

    @JsonAutoDetect
    public static class CurrentDate {

        @JsonProperty
        private long date = new Date().getTime();

        public long getDate() {
            return date;
        }
    }

    @ApiMethod(name = "currentDate")
    public CurrentDate getDate() {
        return new CurrentDate();
    }

It also provides methods to send a message with payload and send to sync message via GCM. This was ripped out the deleted MessageEndpoint.java , so it only sends messages to a maximum of 10 devices. They are both built using GCM’s Message.Builder().

The message with payload adds the time to the data parameter. Key/value pairs added here will be automatically added as extras in the the intent bundle when parsing the message.

    String newTime = String.valueOf(new Date().getTime());
    Message message = new Message.Builder()
            .addData("new_time", newTime)
            .build();

The send-to-sync message uses a collapse key so that only one message will be delivered if multiple tickles are queued up. You should not use more than four distinct keys since that is the maximum number that the GCM server can store. You can read more about this parameter here.

    Message message = new Message.Builder()
            .collapseKey("syncTime")
            .build();

Add send-to-sync and payload message buttons

The index.html in the PushDontPoll-AppEngine project was modified to add buttons that allow us to send the two different types of push messages. Most of the wizard-generated code was removed for simplicity. The code to show the buttons is:

  <div>
      <button id="sendTickleButton">Send Tickle</button>
  </div>

  <div>
      <button id="sendUpdateButton">Send Update</button>
  </div>

The functions that they call are:

  <script type="text/javascript">
    $("#sendTickleButton").click(sendTickle);
    $("#successArea").hide();
  </script>
  <script type="text/javascript">
    $("#sendUpdateButton").click(sendUpdate);
    $("#successArea").hide();
  </script>

  function sendTickle() {
    gapi.client.dateendpoint
    .sendTickle()
    .execute(handleMessageResponse);
  }

  function sendUpdate() {
    gapi.client.dateendpoint
    .sendUpdate()
    .execute(handleMessageResponse);
  }

These call the sendTickle() and sendUpdate() methods in DateEndpoint.java. Make sure you re-generate the client libraries after changing the PushDontPoll-AppEngine code (Tools -> Google Cloud Endpoints -> Generate Client Libraries).

Add code to parse GCM message

The wizard-generated files RegisterActivity.java and GCMIntentService.java were moved to the main project so they could use the Constants class. The added application code to show the saved time was added to the MainActivityclass in order to keep things separated and easy to understand. The RegisterActivity is accessible via an action item.

Parsing the GCM message is done in the onMessage() method in the GCMIntentService class. This class is already fleshed out for you thanks to the wizard.

Parse send-to-sync

The send-to-sync message will have a collapse_key, so we can request a sync if that matches the sync type we’re expecting:

    if ("syncTime".equals(intent.getStringExtra("collapse_key"))) {
        Account[] accounts = AccountManager.get(this).getAccountsByType(Constants.ACCOUNT_TYPE);
        if (accounts.length > 0) {
            Bundle bundle = new Bundle(2);
            bundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
            bundle.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
            ContentResolver.requestSync(accounts[0], Constants.AUTHORITY, bundle);
        }
        [snip]

This uses a sync adapter with a stubbed authenticator and content provider – see here for more info. This can easily be modified to send a network request to sync using your method of choice (Volley, Retrofit, etc) if a sync adapter is not desirable. All of the syncing code is in the com.doubleencore.android.pushdontpoll.sync package, along with the necessary xml files in res/xml/ and in the AndroidManifest.xml.

In the onPerformSync() of the SyncAdapter, we can make a network request to the new endpoint that was created to get the current time:

    Dateendpoint.Builder endpointBuilder = new Dateendpoint.Builder(
            AndroidHttp.newCompatibleTransport(),
            new JacksonFactory(),
            new HttpRequestInitializer() {
                @Override
                public void initialize(HttpRequest httpRequest) throws IOException {
                }
            });

    Dateendpoint endpoint = CloudEndpointUtils.updateBuilder(endpointBuilder).build();
    try {
        CurrentDate date = endpoint.currentDate().execute();
        long time = date.getDate();
        [snip]

Parse message with payload

The message with payload will have new_time as a key in the intent extras. This key coincides with the one we added when building the message. You can read more about the data parameter here.

    if (intent.hasExtra("new_time")) {
        // Extract the data from the message
        long time = Long.parseLong(intent.getStringExtra("new_time"));
        [snip]

In both cases, the time is then saved to shared preferences, and a local broadcast is sent to update the UI. Again, this can be done using your preferred method (event bus, observable cursor, etc).

    SharedPreferences.Editor editor = getSharedPreferences(Constants.PREFS_NAME, 0).edit();
    editor.putLong(Constants.PREFS_KEY_TIME, time).apply();

    Intent updateIntent = new Intent(Constants.UPDATE_UI_INTENT_ACTION);
    LocalBroadcastManager.getInstance(this).sendBroadcast(updateIntent);

Running the server

In order to use GCM, you must have an API key. You can enter this when running the wizard or by replacing it in DateEndpoint.java in the PushDontPoll-AppEngine project. The server can either be deployed as an App Engine app or run locally using the dev server.

Local instance

To run it as a local instance, you need to change:

    //PushDontPoll-endpoints Project - CloudEndpointUtils.java
    protected static final boolean LOCAL_ANDROID_RUN = true;

Then you can just run the appengine:devserver maven goal, and it will be running on localhost. The server will now work with a Google API emulator.

If you want to access this local instance on a device (it must be on the same network as the local instance,) you’ll also need to change:

    //PushDontPoll-endpoints Project - CloudEndpointUtils.java
    protected static final String LOCAL_APP_ENGINE_SERVER_URL_FOR_ANDROID = "http://[local_ip_address]:8080";

…and download the App Engine SDK from here, and run:

    appengine-java-sdk/bin/dev_appserver.sh --address 0.0.0.0 [project_directory]/PushDontPoll-Appegine/target/PushDontPoll-AppEngine-1.0

App Engine app

If you didn’t follow along in the blog and are just trying to get the sample code running, you need to create a Google Cloud Platform project and obtain the Project Number and Project ID. You can do this by following the Preliminary Setup section of this blog post.

Set the PROJECT_NUMBER variable in GCMIntentService.java to your project number and the <application> tag in appengine-web.xml to your project ID, and regenerate the client libraries.

You may also want to change the packages (com.doubleencore.android) and domains (doubleencore.com) to your domain.

Deploy the backend server by running the appengine:update maven goal. You can then access your server athttp://<project-id>.appspot.com.

Running the Android app

You can now deploy the PushDontPoll app to your device or emulator. Once deployed, click on the GCM Register action item to register your device with the server. Once the success message appears, press back and navigate to your server on your computer. Pressing the “Send Tickle” button will push a message that signals the device to sync with the server. The device will hit the date endpoint for the current time, and the time should refresh on the device. Pressing the “Send Update” button will push a message that has the new time in the payload data. This should instantly update the time shown on the device without needing to make an additional trip to the server.

Hopefully, this simple example app will assist you in getting a push framework up and running for your app. I highly recommend reading through the GCM documentation to get a thorough understanding, as there are many features not discussed in this article. You will need to handle things, such as request spikes with send-to-sync messages, more gracefully than this sample does as well. Good luck and happy pushing!

文章节选：http://www.doubleencore.com/2013/09/push-dont-poll-how-to-use-gcm-to-update-app-data/

Android云推送之GCM，首发于润物无声。

1. C++ 调用 C 语言

头文件包含：

extern "C"
{
#include "iec61850_server.h"
#include "iso_server.h"
#include "acse.h"
#include "thread.h"
#include "model.h"
}

函数调用：

IedServer_observeDataAttribute(iedServer, (DataAttribute*)mmsi.dmm, observerCallback);

回调函数observerCallback的声明和实现如下：

extern "C"
{
  void observerCallback(DataAttribute* dataAttribute)
  {
    call_Lib_daObserverCallback(mod, dataAttribute);
  }
}

2. C 调用 C++ 语言

在C语言的函数中是无法直接调用C++代码的，如果要调用，需要做一个wrapper，例如call_Lib_daObserverCallback，它的声明和实现如下：

extern "C" void call_Lib_daObserverCallback(Lib* p, DataAttribute* dataAttribute) // wrapper function
{
   p->daObserverCallback(dataAttribute);
}

daObserverCallback 才是我们C++代码的实现：

void Lib::daObserverCallback(DataAttribute* dataAttribute)
{
  map<string, MMSINFO>::iterator it;
  // ...
}

备忘：C与C++之间的互相调用，首发于润物无声。

【系统整体架构】

1. PC端本地通过OpenScada系统采集温湿度的数据
2. PC端本地将采集到的温湿度数据定时上报到云端，供PAD查询
3. PC端本地检测温湿度的阀值，启动或者关闭报警设备
4. PC端本地检测到报警信息，及时给云端报告告警信息，云端通过微信系统推送到系统管理员账号上
5. 系统管理员通道PAD微信系统，查询当前环境的数据

【硬件环境】
1. 工作PC，ubuntu系统，运行openscada数据采集系统
2. PAD一台，手机也可以，模拟器也行，能跑微信就行
3. USB-485 转接器，PC上没有485端口，需要转换成USB通信协议
3. FT-02RL开关量输入输出模块(MODBUS-RTU协议)，软件控制继电器开关
4. 温湿度传感器，基于485 modbus的数据传输协议

【硬件布线】
1. 注意一下电源的正负极，不要接反了
2. 注意485的A B数据端口，不要接反了
3. 其他的没啥问题了

【软件环境】
1. 本地PC运行Ubuntu 12.04 OS
2. 本地实现OpenScada数据采集系统，可以采集Modbus协议的数据，和基于Modbus协议控制外设
3. 远端的PHP服务器，采用的我博客（http://blog.zhourunsheng.com）的后台，基于wordpress + 插件
4. 微信公众号的接入，像我下面的微信号是专门为博客服务的

【演示数据查询】
1. 加入公众微信号，查询关键字“zhou_runsheng”，或者扫描如下的二维码，添加

2. 发送查询指令，例如“查询温湿度”，返回当前环境温湿度数据
<<< 查询温湿度
>>> 温湿度数据：
温度：33.5 度
湿度：88.7%
露点：18.7 度

3. 其他的指令还没有加入，如果输入其他的查询信息，默认会按照该关键词来搜索相关的博文展示

【演示报警】
1. 加热温湿度采集器（O(∩_∩)O，用火烤烤，甭烧毁仪器就行）
2. 加湿温湿度采集器（最简单的办法，对着仪器哈口气，湿度立马上升到99.99%）
3. 当温湿度达到管理员配置的临界阀值（比如温度超过33摄氏度），产生报警
4. 报警产生，报警器响铃，微信推送通知系统管理员

5. 湿度报警, 继电器开关打开,左数第一个亮起来的红灯

【未来】
目前仅仅实现了简单的数据采集+报警应急处理，推广到其他地方，比如智能家居，智能农田灌溉，智能监控系统等等，O(∩_∩)O哈哈~，先想想怎么样打造一套智能的家居吧~~~，把家里联网的东西全控制了。

体验物联网，首发于润物无声。