2. 程式人生 > >Android應用程序訪問linux驅動第一步：實現並測試Linux驅動

Android應用程序訪問linux驅動第一步：實現並測試Linux驅動

阿新 • • 發佈：2017-10-22
sizeof 屬性文件 rup sla 沒有 lov /dev/ art kmalloc

一直都想親自做一次使用android應用程序訪問Linux內核驅動的嘗試，但總是沒能做到。最近抽出時間，下決心重新嘗試一次。嘗試的開始當然是先寫一個Linux內核驅動了。
我希望寫一個簡單測驅動程序，實現寫一個字符串進去，然後再把它讀出來的功能。驅動中會創建dev/hello設備節點和/sys/class/hello/hello/val 設備節點，沒有實現proc/下的對應的設備節點。/sys/class/hello/hello/val 主要用於快速測試，而dev/hello則主要用於供上層應用調用。
這篇博客參考了老羅的android之旅相關博客：http://blog.csdn.net/luoshengyang/article/details/6568411。

一。驅動源碼

代碼我已經在android6.0的linux kernel上測試過了，代碼中有響應的註釋，所以這裏直接貼出代碼：

hello.c

文件如下：

#include <linux/init.h>  
#include <linux/module.h>  
#include <linux/types.h>  
#include <linux/fs.h>  
#include <linux/proc_fs.h>  
#include <linux/device.h>  

#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/fcntl.h>

#include <linux/poll.h>
#include <linux/seq_file.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>

#include <asm/uaccess.h>
#include <linux/slab.h>


#include "hello.h"  

/*定義主設備和從設備號變量*/  
static int hello_major = 0;  
static int hello_minor = 0;  

/*設備類別和設備變量*/  
static struct class* hello_class = NULL;  
static struct hello_test_dev* hello_dev = NULL;  

/*傳統的設備文件操作方法*/  
static int hello_open(struct inode* inode, struct file* filp);  
static int hello_release(struct inode* inode, struct file* filp);  
static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos);  
static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos);  

/*設備文件操作方法表*/  
static struct file_operations hello_fops = {  
    .owner = THIS_MODULE,  
    .open = hello_open,  
    .release = hello_release,  
    .read = hello_read,  
    .write = hello_write,   
};  

/*訪問設置屬性方法*/  
static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr,  char* buf);  
static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count);  

/*定義設備屬性*/  
static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, hello_val_show, hello_val_store); 

/*打開設備方法*/  
static int hello_open(struct inode* inode, struct file* filp) {  
    struct hello_test_dev* dev;          

    /*將自定義設備結構體保存在文件指針的私有數據域中，以便訪問設備時拿來用*/  
    dev = container_of(inode->i_cdev, struct hello_test_dev, dev);  
    filp->private_data = dev;  

    return 0;  
}  

/*設備文件釋放時調用，空實現*/  
static int hello_release(struct inode* inode, struct file* filp) {  
    return 0;  
}  

/*讀內存*/  
static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos) {  
    ssize_t err = 0;  
    struct hello_test_dev* dev = filp->private_data;          

    /*同步訪問*/  
    if(down_interruptible(&(dev->sem))) {  
        return -ERESTARTSYS;  
    }  

    if(count < sizeof(dev->val)) {  
        goto out;  
    }          

    /*讀字符串*/  
    if(copy_to_user(buf, dev->val, sizeof(dev->val))) {  
        err = -EFAULT;  
        goto out;  
    }  

    err = sizeof(dev->val);  

out:  
    up(&(dev->sem));  
    return err;  
}  

/*寫字符串*/  
static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos) {  
    struct hello_test_dev* dev = filp->private_data;  
    ssize_t err = 0;          

    /*同步訪問*/  
    if(down_interruptible(&(dev->sem))) {  
        return -ERESTARTSYS;          
    }          

    if(count != sizeof(dev->val)) {  
        goto out;          
    }          

    /*將用戶寫進來的字符串保存到驅動的內存中*/  
    if(copy_from_user(dev->val, buf, count)) {  
        err = -EFAULT;  
        goto out;  
    }  

    err = sizeof(dev->val);  

out:  
    up(&(dev->sem));  
    return err;  
}  


/*寫字符串到內存*/  
static ssize_t __hello_set_val(struct hello_test_dev* dev, const char* buf, size_t count) {       

    /*同步訪問*/          
    if(down_interruptible(&(dev->sem))) {                  
        return -ERESTARTSYS;          
    }          
    printk(KERN_ALERT"__hello_set_val.buf: %s  count:%d\n",buf,count);
    printk(KERN_ALERT"__hello_set_val.dev->val: %s  count:%d\n",dev->val,count);
    strncpy(dev->val,buf, count);
    printk(KERN_ALERT"__hello_set_val.dev->val: %s  count:%d\n",dev->val,count);
    up(&(dev->sem));  

    return count;  
}  

/*讀取設備屬性val*/  
static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr, char* buf) {  
    struct hello_test_dev* hdev = (struct hello_test_dev*)dev_get_drvdata(dev);          
    printk(KERN_ALERT"hello_val_show.\n");
    printk(KERN_ALERT"%s\n",hdev->val);
    return 0;
}  

/*寫設備屬性val*/  
static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count) {   
    struct hello_test_dev* hdev = (struct hello_test_dev*)dev_get_drvdata(dev);    
    printk(KERN_ALERT"hello_val_store.buf: %s  count:%d\n",buf,count);

    return __hello_set_val(hdev, buf, count);  
}  


/*初始化設備*/  
static int  __hello_setup_dev(struct hello_test_dev* dev) {  
    int err;  
    dev_t devno = MKDEV(hello_major, hello_minor);  

    memset(dev, 0, sizeof(struct hello_test_dev));  

    cdev_init(&(dev->dev), &hello_fops);  
    dev->dev.owner = THIS_MODULE;  
    dev->dev.ops = &hello_fops;          

    /*註冊字符設備*/  
    err = cdev_add(&(dev->dev),devno, 1);  
    if(err) {  
        return err;  
    }          

    /*初始化信號量和寄存器val的值*/  
    init_MUTEX(&(dev->sem));  
    dev->val = kmalloc(10,GFP_KERNEL);  
    strncpy(dev->val,"hello",sizeof("hello"));
    return 0;  
}  

/*模塊加載方法*/  
static int __init hello_init(void){   
    int err = -1;  
    dev_t dev = 0;  
    struct device* temp = NULL;  

    printk(KERN_ALERT"hello_init.\n");          

    /*動態分配主設備和從設備號*/  
    err = alloc_chrdev_region(&dev, 0, 1, HELLO_DEVICE_NODE_NAME);  
    if(err < 0) {  
        printk(KERN_ALERT"Failed to alloc char dev region.\n");  
        goto fail;  
    }  

    hello_major = MAJOR(dev);  
    hello_minor = MINOR(dev);          

    /*分配helo設備結構體變量*/  
    hello_dev = kmalloc(sizeof(struct hello_test_dev), GFP_KERNEL);  
    if(!hello_dev) {  
        err = -ENOMEM;  
        printk(KERN_ALERT"Failed to alloc hello_dev.\n");  
        goto unregister;  
    }          

    /*初始化設備*/  
    err = __hello_setup_dev(hello_dev);  
    if(err) {  
        printk(KERN_ALERT"Failed to setup dev: %d.\n", err);  
        goto cleanup;  
    }          

    /*在/sys/class/目錄下創建設備類別目錄hello*/  
    hello_class = class_create(THIS_MODULE, HELLO_DEVICE_CLASS_NAME);  
    if(IS_ERR(hello_class)) {  
        err = PTR_ERR(hello_class);  
        printk(KERN_ALERT"Failed to create hello class.\n");  
        goto destroy_cdev;  
    }          

    /*在/dev/目錄和/sys/class/hello目錄下分別創建設備文件hello*/  
    temp = device_create(hello_class, NULL, dev, "%s", HELLO_DEVICE_FILE_NAME);  
    if(IS_ERR(temp)) {  
        err = PTR_ERR(temp);  
        printk(KERN_ALERT"Failed to create hello device.");  
        goto destroy_class;  
    }          

    /*在/sys/class/hello/hello目錄下創建屬性文件val*/  
    err = device_create_file(temp, &dev_attr_val);  
    if(err < 0) {  
        printk(KERN_ALERT"Failed to create attribute val.");                  
        goto destroy_device;  
    }  

    dev_set_drvdata(temp, hello_dev);          

    printk(KERN_ALERT"Succedded to initialize hello device.\n");  
    return 0;  

destroy_device:  
    device_destroy(hello_class, dev);  

destroy_class:  
    class_destroy(hello_class);  

destroy_cdev:  
    cdev_del(&(hello_dev->dev));  

cleanup:  
    kfree(hello_dev);  

unregister:  
    unregister_chrdev_region(MKDEV(hello_major, hello_minor), 1);  

fail:  
    return err;  
}  

/*模塊卸載方法*/  
static void __exit hello_exit(void) {  
    dev_t devno = MKDEV(hello_major, hello_minor);  

    printk(KERN_ALERT"hello_exit\n");          

    /*銷毀設備類別和設備*/  
    if(hello_class) {  
        device_destroy(hello_class, MKDEV(hello_major, hello_minor));  
        class_destroy(hello_class);  
    }          

    /*刪除字符設備和釋放設備內存*/  
    if(hello_dev) {  
        cdev_del(&(hello_dev->dev));  
        kfree(hello_dev);  
    }          
    if(hello_dev->val != NULL){
     kfree(hello_dev->val);
    }
    /*釋放設備號*/  
    unregister_chrdev_region(devno, 1);  
}  

MODULE_LICENSE("GPL");  
MODULE_DESCRIPTION("Test Driver");  

module_init(hello_init);  
module_exit(hello_exit);
  • 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
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291

hello.h

文件如下：

#ifndef _HELLO_TEST_H_  
#define _HELLO_ANDROID_H_  

#include <linux/cdev.h>  
#include <linux/semaphore.h>  

#define HELLO_DEVICE_NODE_NAME  "hello"  
#define HELLO_DEVICE_FILE_NAME  "hello"  
#define HELLO_DEVICE_CLASS_NAME "hello"  

struct hello_test_dev {  
    char * val;  
    struct semaphore sem;  
    struct cdev dev;  
};  

#endif
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

二。編譯驅動

在linux源碼目錄的driver下新建hello目錄，把hello.c和hello.h文件放入其中。新增Makefile和Kconfig文件：

1.Makefile,用於編譯驅動

obj-$(CONFIG_HELLO) += hello.o
  • 1

2.Kconfig

       config HELLO
           tristate "Test Driver"
           default n
           help
           This is the test driver.
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

3修改driver目錄下的Makefile:

添加如下一項：

obj-$(CONFIG_HELLO) += hello/
  • 1

4.修改driver目錄下的Kconfig

添加如下一項：

source "drivers/hello/Kconfig"
  • 1

5.make menuconfig

如果對編譯linux kernel不熟悉請自行百度。
配置界面如下：
技術分享

可以看到這裏出現了我們在Kconfig中添加的Test Driver選項，我們把它選擇成以模塊的形式編譯，這更有利於我們的測試，這樣我們就不需要重新少些linux kernel了。Android的linux kernel一般是打包進boot.img文件的，如果想把模塊編譯進Linux內核，並且重寫燒寫linux kernel ，建議把kernel放到out/target/product/xxx/目錄下，然後使用make bootimage-nodeps能快速生成boot.img文件，具體kernel放置的位置還需要看android編譯系統相關配置，這裏就不深究了。

6.make -j16

執行make -j16(-j16標示使用16個cpu來編譯，只是個請求)，這個過程還是很快的，幾分鐘就可以編譯成功。編譯後的hello目錄如下：
技術分享
可以看到生成了hello.ko文件。

三.使用/sys/class/hello/hello/val 進行測試

1.把hello.ko拷貝到android設備上

建議直接使用adb push hello.ko /data 即可，也可以用U盤拷貝。總之，把它放到android設備上。

2.裝載驅動

cd /data
insmod hello.ko
這個時候可以看到/dev/hello /sys/class/hello/hello/val文件已經出現

3.測試

輸入命令：echo haha > val
打印如下：
[ 9641.053505] hello_val_store.buf: haha
[ 9641.053505] count:5
[ 9641.060167] __hello_set_val.buf: haha
[ 9641.060167] count:5
[ 9641.066841] __hello_set_val.dev->val: hello count:5
[ 9641.073088] __hello_set_val.dev->val: haha
[ 9641.073088] count:5
可以看到數據已經寫入，
使用cat val 讀取：
打印如下：
[ 9644.953496] hello_val_show.
[ 9644.957127] haha
[ 9644.957127]
可以看到haha打印出來了，書名寫入是成功的。

四.使用/dev/hello測試

首先在android源碼的packages目錄下新建一個hellotest目錄，該目錄下新建hellotest.c和Android.mk兩個文件。

1.hellotest.c

這個文件用來打開/dev/hello文件並嘗試讀和寫字符串操作，並打印相關信息，源碼如下：

#include <stdio.h>  
#include <stdlib.h>  
#include <fcntl.h>  
#define HELLO_DEVICE "/dev/hello"  
int main(int argc, char** argv)  
{  
    int fd = -1;  
    char * str = malloc(10);
    //打開/dev/hello
    fd = open(HELLO_DEVICE, O_RDWR);  
    if(fd == -1) {  
        printf("Failed to open device %s.\n", HELLO_DEVICE);  
        return -1;  
    }  

    printf("Read original value:\n"); 
    //先讀一次數據看看
    read(fd, str, 10);  
    printf("read data: %s\n", str);  
    strncpy(str,"nihao",sizeof("nihao"));  
    printf("write nihao\n");  
    //寫nihao進去
    write(fd, str, sizeof(str));  

    printf("Read the value again:\n");  
    //讀看看是不是nihao
        read(fd, str, 10);  
        printf("read data: %s\n", str);  
    close(fd);  
    return 0;  
}
  • 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

2.Android.mk

android下編譯應用程序使用Android.mk還是很方便的：

      LOCAL_PATH := $(call my-dir)

      include $(CLEAR_VARS)

      LOCAL_MODULE_TAGS := optional

      LOCAL_MODULE := hellotest

      LOCAL_SRC_FILES := $(call all-subdir-c-files)

      include $(BUILD_EXECUTABLE)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

3.編譯

執行mm命令即可
編譯後的文件在out/target/product/xxx/obj/EXECUTABLES/hellotest_intermediates/目錄下，該目錄編譯後如圖：
技術分享
關於mm命令編譯執行文件的過程，可以參考我的這篇博客： Android編譯系統<二>-mm編譯單個模塊

4.測試

使用adb push hellotest /data把hellotest 推送到android設備上來，然後chmod +x hellotest添加可執行權限。
最後./hellotest
打印如下：

Read original value:
read data: hell
write nihao
Read the value again:
read data: nihao
  • 1
  • 2
  • 3
  • 4
  • 5

可見測試成功。

版權聲明：本文為博主原創文章，未經博主允許不得轉載。

Android應用程序訪問linux驅動第一步：實現並測試Linux驅動

相關推薦

Android應用程序訪問linux驅動第一步：實現並測試Linux驅動

sizeof 屬性文件 rup sla 沒有 lov /dev/ art kmalloc 一直都想親自做一次使用android應用程序訪問Linux內核驅動的嘗試，但總是沒能做到。最近抽出時間，下決心重新嘗試一次。嘗試的開始當然是先寫一個Linux內核驅動了。 我希望

Android應用程式訪問linux驅動第三步：實現並向系統註冊Service

前面兩篇部落格記錄了實現Linux驅動和使用HAL層訪問Linux驅動的程式碼，我們分別對這兩部分做了測試，他們都正常工作。有了前面的基礎，我們就可以實現service層了，我們想系統註冊我們自己的service,在service中訪問HAL層，在HAL層中訪問

PyCharm入門第一步：建立並執行第一個Python專案

步驟1：建立並執行您的第一個Python專案 在你開始之前 確保滿足以下先決條件： 您正在使PyCharmCE或Professional。 您已經安裝了Python本身。如果您使用的是macOS或Linux，那麼您的計算機已經安裝了Python。你可以從python.org獲

Eclipse+超快的模擬器Genymotion開發Android應用（第一步：安裝及配置Genymotion）

一、安裝及配置Genymotion （1）由於Eclipse中自帶的SDK模擬器，啟動之慢，不說了 現在給大家介紹一種比較快的模擬器Genymotion （2）首先去Genymotion的官網註冊一個賬號，這個賬號是有用的 請記著你的賬號和密碼（我用的是QQ好註冊的）

Linux學習第一步（虛擬機的和鏡像文件的安裝）

image 下載文件 型號 啟動 計算機 服務 .cn img blog 一、安裝虛擬機（本文以vmware workstation 12為例） 　　1.在網上所有虛擬機並下載。 　　2.找到下載文件安裝好 　　3.一直下一步 　　4.接下來的就是選擇安裝的目錄了，當

關於Android應用程序漏洞的防護措施

android 應用程序 移動應用 開發者 目前，Android應用程序市場的發展速度飛快，不少開發者為了追求開發速度而忽視應用程序的安全。但由於Android系統的開源性及其Java編寫的特殊性，各類Android App經常被爆出漏洞，有的Android開發者只是對App進行

最優雅退出 Android 應用程序的 6 種方式

home鍵 應用 一點 container new 出棧 manage 而且 rec 一、容器式建立一個全局容器，把所有的Activity存儲起來，退出時循環遍歷finish所有Activity import java.util.ArrayList; impor

【苦讀官方文檔】2.Android應用程序基本原理概述

project 做出 系統默認 體驗 告訴 sta 執行過程 顏色 硬件配置 官方文檔原文地址 應用程序原理 Android應用程序是通過Java編程語言來寫。Android軟件開發工具把你的代碼和其它數據、資源文件一起編譯、打包成一個APK文件

在Android應用程序中實現推送通知

xamarin android 幾乎每一個應用程序的一個重要特性是支持推送通知的能力。使用推送通知，您可以更新用戶，而不需要應用程序在任何時候運行或輪詢服務器， 避免潛在的電池電量不足。 隨著火力點雲信息的介紹（FCM），谷歌使得在Android應用程序中實現推送通知變

讓你的Xamarin.Forms應用程序訪問

xamarin android 註意：在Xamarin.Forms 2.3.5-pre3發布版，我們將類名Accessibility變更為AutomationProperties。 iOS、Android和Windows都公開了開發人員為每個人構建可訪問

Andoid之硬件訪問服務1（讓Andoid應用程序訪問c庫）

es2017 項目 ktr 按鈕 jint 開發板 height eight sign andoid 項目文件結構圖 新建Hardcontrol.java package com.thisway.hardlibrary; public class Har

C#使用Xamarin開發Android應用程序 -- 系列文章

android界面 百度 0.11 itl 利用 設備 android安裝 tor href Xamarin開發Android應用程序 利用Xamaria構建Android應用-公交發車信息屏 Xamarin版的C# SVG路徑解析器 C#使用Xamarin開發可移植

安裝Linux虛擬機器--踏上Linux的第一步

安裝Linux虛擬機器 VMware workstation是VMware公司設計的專業虛擬機器，可以虛擬現有任何作業系統，而且使用簡單，容易上手。 要知道所有微軟員工的機器上都裝有一套正版的VMware，足見它在這方面的權威。 從某種意義上說，一臺物理計算機

如何讓我們的Android應用程序保活？

一、執行緒 程序 應用 預設下，同一個應用的所有元件都執行在同一個程序中。當然也可以在manifest清單檔案中設定元件執行的程序。 元件元素 activity、service、receiver、provider，都有一個process屬性可以指定元

Linux初學第一步——虛擬機器

一、虛擬機器的下載與安裝 下載：可以百度VMware，直接進入官網。它的網址為www.VMware.com ->下載區 ->下載VMware Player for Windows 32-bit or 64-bit軟體，不過好像現在只有64-bit了

Android應用中訪問HTTPS方式

HTTPS和HTTP的區別 一、https協議需要到ca申請證書，一般免費證書很少，需要交費。 二、http是超文字傳輸協議，資訊是明文傳輸，https 則是具有安全性的ssl加密傳輸協議。 三、http和https使用的是完全不同的連線方式，用的埠也不一樣，前者是80，後者是443。 四、htt

Android應用程序升級後自動進入新版本

在新版本中建立一個Receiver接收手機應用的安裝和解除安裝（可以監聽到舊版本的解除安裝） package com.justsy.lpi.receiver;   import android.content.BroadcastReceiver;   import

Android 應用程序啟動流程

我們知道啟動Activity時，在ActivityStackSupervisor.java中函式startSpecificActivityLocked裡面會判斷當前Activity所在application是否已經啟動，如果啟動，則直接建立Activity也即呼叫realS

Android 應用程序啟動流程

閱讀的收益 討論的內容也就是一個應用程序是如何啟動的，私以為這一部分的內容頗為重要，即便不瞭解細節，也要知道其中的大體步驟。特別是針對我們應用開發者而言，理應瞭解我們的 App 是如何被啟動的，App 中的元件是如何被系統服務呼叫和組織的。 講應用程序啟動的文章不是很多，也

第一步，用qemu啟動linux核心，從跑個Helloworld開始

       老生長談的內容了，就是自己編譯核心，然後製作initramfs，在用qemu跑 起來。不過在這之前先跑個helloworld玩玩。順便我在學校寫部落格的筆記本系統是ubuntu16.04,在實習單位玩的時候用的系統是centos7,兩個不同的地方我會盡量說明，