AndroidFramework

#include <stdio.h>
#include <stdlib.h>

#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>


#define IPCKEY 0x366378



typedef struct st_setting
{
    char agen[10];
    unsigned char file_no;
}st_setting;

int main(int argc, char** argv)
{
    int         shm_id;
    //key_t       key;
    st_setting  *p_setting;

    //  首先检查共享内存是否存在，存在则先删除
    shm_id = shmget(IPCKEY , 1028, 0640);
    if(shm_id != -1)
    {
        p_setting = (st_setting *)shmat(shm_id, NULL, 0);

        if (p_setting != (void *)-1)
        {
            shmdt(p_setting);

            shmctl(shm_id,IPC_RMID,0) ;
        }
    }

    //  创建共享内存
    shm_id = shmget(IPCKEY, 1028, 0640 | IPC_CREAT | IPC_EXCL);
    if(shm_id == -1)
    {
        printf("shmget error\n");
        return -1;
    }

    //  将这块共享内存区附加到自己的内存段
    p_setting = (st_setting *)shmat(shm_id, NULL, 0);

    strncpy(p_setting->agen, "gatieme", 10);
    printf("agen : %s\n", p_setting->agen);

    p_setting->file_no = 1;
    printf("file_no : %d\n",p_setting->file_no);

    system("ipcs -m");//  此时可看到有进程关联到共享内存的信息，nattch为1

    //  将这块共享内存区从自己的内存段删除出去
    if(shmdt(p_setting) == -1)
       perror(" detach error ");

    system("ipcs -m");//  此时可看到有进程关联到共享内存的信息，nattch为0

    //  删除共享内存
    if (shmctl( shm_id , IPC_RMID , NULL ) == -1)
    {
        perror(" delete error ");
    }

    system("ipcs -m");//  此时可看到有进程关联到共享内存的信息，nattch为0


    return EXIT_SUCCESS;
}

//shmDatadef.h
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/shm.h>
#include <iostream>
using namespace std;
#define SHARE_MEMORY_BUFFER_LEN 1024
struct stuShareMemory{
	int iSignal;
	char chBuffer[SHARE_MEMORY_BUFFER_LEN];
	
	stuShareMemory(){
		iSignal = 0;
		memset(chBuffer,0,SHARE_MEMORY_BUFFER_LEN);
	}
};

//writeShareMemory.cpp
#include "shmDatadef.h"
int main(int argc, char* argv[])
{
	void *shm = NULL;
	struct stuShareMemory *stu = NULL;
	int shmid = shmget((key_t)1234, sizeof(struct stuShareMemory), 0666|IPC_CREAT);
	if(shmid == -1)
	{
		printf("shmget err.\n");
		return 0;
	}
	shm = shmat(shmid, (void*)0, 0);
	if(shm == (void*)-1)
	{
		printf("shmat err.\n");
		return 0;
	}

	stu = (struct stuShareMemory*)shm;

	stu->iSignal = 0;

	//while(true) //如果需要多次 读取 可以启用 while
	{
		if(stu->iSignal != 1)
		{
			printf("write txt to shm.");
			memcpy(stu->chBuffer, "hello world 666 - 888.\n", 30);
			stu->iSignal = 1;
		}
		else
		{
			sleep(10);
		}
	}
	
	shmdt(shm);

	std::cout << "end progress." << endl;
	return 0;
}

//readShareMemory.cpp

#include "shmDatadef.h"

int main(int argc, char* argv[])
{
	void *shm = NULL;
	struct stuShareMemory *stu;
	int shmid = shmget((key_t)1234, sizeof(struct stuShareMemory), 0666|IPC_CREAT);
	if(shmid == -1)
	{
		printf("shmget err.\n");
		return 0;
	}

	shm = shmat(shmid, (void*)0, 0);
	if(shm == (void*)-1)
	{
		printf("shmat err.\n");
		return 0;
	}

	stu = (struct stuShareMemory*)shm;

	stu->iSignal = 1;

	//while(true)  //如果需要多次写入，可以启用while
	{
		if(stu->iSignal != 0)
		{
			printf("current txt : %s", stu->chBuffer);
			stu->iSignal = 0;
		}
		else
		{
			sleep(10);
		}
	}
	
	shmdt(shm);
	shmctl(shmid, IPC_RMID, 0);

	std::cout << "end progress." << endl;
	return 0;
}

#include<iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<string.h>
#include <signal.h>
#define FIFO  "/home/whb/projects/11.fifo" //有名管道的名字

using namespace std;
int main()
{
	int result , fd;//result 为接收mkfifo的返回值   fd为打开文件的文件描述符
	char buffer[20] = { 0 };//定义一个字符数据
	if (access(FIFO, F_OK)==-1)//判断是否已经创建了有名管道，如果已经创建，则返回0 否则返回非0的数
	{
		result = mkfifo(FIFO, 0777);//创建有名管道,成功返回0,失败返回-1
		if (result < 0)
		{
			perror("creat mkfifo error");
			return 0;
		}
	}
	cout << "请输入数据：" << endl;
	//以只写方式打开有名管道，不能同时以读写权限打开,成功返回文件描述符，失败返回 - 1
	fd = open(FIFO,O_WRONLY);
	if (fd < 0)
	{
		perror("open error");
		return 0;
	}
	while (1)
	{
		fgets(buffer, sizeof(buffer), stdin);//从终端输入数据到buffer中
		write(fd, buffer, strlen(buffer));//数据写到有名管道
		memset(buffer, 0x0, sizeof(buffer));//清空缓存区
	}
	close(fd);//关闭有名管道
	return 0;
}

#include<iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<string.h>
#include <signal.h>
#define FIFO  "/home/whb/projects/11.fifo"//有名管道的名字
using namespace std;

int main()
{
	int result ,fd;//result 接收mkfifo 的返回值  fd 文件描述符
	char buffer[20] = { 0 };
	if (access(FIFO, F_OK)==-1)//判断有名管道是否存在  不存在就创建  存在就不创建   已经创建返回0  否则非0
	{
		result = mkfifo(FIFO, 0777);//创建有名管道  0 成功   -1 失败
		if (result < 0)
		{
			perror("creat mkfifo error");
			return 0;
		}
	}
	fd = open(FIFO, O_RDONLY);//只读的方式打开  返回小于0的值为打开失败
	if (fd < 0)
	{
		perror("open error");
		return 0;
	}
	while (1)
	{
		read(fd, buffer, sizeof(buffer));
		cout << "buffer= " << buffer << endl;
		memset(buffer,0,sizeof(buffer));
	}
	close(fd);//关闭有名管道
	return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/un.h>
#include<errno.h>

//define send and recv buf size
#define BUFSIZE 512*1024

//define unix domain socket path
#define pmmanager "/tmp/pmmanager"
#define pmapi "/tmp/pmapi"

int main(int argc, char** argv)
{
    char rx_buf[BUFSIZE];
    int pmmanager_fd, ret;
    socklen_t len;
    struct sockaddr_un pmmanager_addr, pmapi_addr;

    //create pmmanager socket fd
    pmmanager_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if(pmmanager_fd == -1)
    {
        perror("cannot create pmmanager fd.");
    }

    unlink(pmmanager);
    memset(&pmmanager_addr, 0, sizeof(pmmanager_addr));
    pmmanager_addr.sun_family = AF_UNIX;
    strncpy(pmmanager_addr.sun_path, pmmanager, sizeof(pmmanager_addr.sun_path)-1);

    //bind pmmanager_fd to pmmanager_addr
    ret = bind(pmmanager_fd, (struct sockaddr*)&pmmanager_addr, sizeof(pmmanager_addr));
    if(ret == -1)
    {
        perror("can not bind pmmanager_addr");
    }

    int recvBufSize;
    len = sizeof(recvBufSize);
    ret = getsockopt(pmmanager_fd, SOL_SOCKET, SO_RCVBUF, &recvBufSize, &len);
    if(ret ==-1)
    {
        perror("getsocket error.");
    }
    printf("Before setsockopt, SO_RCVBUF-%d\n",recvBufSize); 
    recvBufSize = 512*1024;
    ret = setsockopt(pmmanager_fd, SOL_SOCKET, SO_RCVBUF, &recvBufSize, len);
    if(ret == -1)
    {
        perror("setsockopt error.");
    }
    ret = getsockopt(pmmanager_fd, SOL_SOCKET, SO_RCVBUF, &recvBufSize, &len);
    if(ret ==-1)
    {
        perror("getsocket error.");
    }
    printf("Set recv buf successful, SO_RCVBUF-%d\n",recvBufSize); 

    int recvSize;
    memset(&pmapi_addr, 0, sizeof(pmapi_addr));
    len = sizeof(pmapi_addr);
    printf("==============wait for msg from pmapi====================\n");
    for(;;)
    {
        memset(rx_buf, 0, sizeof(rx_buf));
        recvSize = recvfrom(pmmanager_fd, rx_buf, sizeof(rx_buf), 0, (struct sockaddr*)&pmapi_addr, &len);
        if(recvSize == -1)
        {
            perror("recvfrom error.");
        }
        printf("Recved message from pmapi: %s\n", rx_buf);
    }
}

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/un.h>
#include<errno.h>

//define send and recv buf size
#define BUFSIZE 250*1024

//define unix domain socket path
#define pmmanager "/tmp/pmmanager"
#define pmapi "/tmp/pmapi"

int main(int argc, char** argv)
{
    char tx_buf[BUFSIZE];
    int pmapi_fd, ret;
    socklen_t len;
    struct sockaddr_un pmmanager_addr, pmapi_addr;

    //create pmmanager socket fd
    pmapi_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if(pmapi_fd == -1)
    {
        perror("cannot create pmapi fd.");
    }

    unlink(pmapi);
    //configure pmapi's addr
    memset(&pmapi_addr, 0, sizeof(pmapi_addr));
    pmapi_addr.sun_family = AF_UNIX;
    strncpy(pmapi_addr.sun_path, pmapi, sizeof(pmapi_addr.sun_path)-1);
    //bind pmapi_fd to pmapi_addr
    ret = bind(pmapi_fd, (struct sockaddr*)&pmapi_addr, sizeof(pmapi_addr));
    if(ret == -1)
    {
        perror("bind error.");
    }

    int sendBufSize;
    len = sizeof(sendBufSize);
    ret = getsockopt(pmapi_fd, SOL_SOCKET, SO_SNDBUF, &sendBufSize, &len);
    if(ret ==-1)
    {
        perror("getsocket error.");
    }
    printf("Before setsockopt, SO_SNDBUF-%d\n",sendBufSize); 
    sendBufSize = 512*1024;
    ret = setsockopt(pmapi_fd, SOL_SOCKET, SO_SNDBUF, &sendBufSize, len);
    if(ret == -1)
    {
        perror("setsockopt error.");
    }
    ret = getsockopt(pmapi_fd, SOL_SOCKET, SO_SNDBUF, &sendBufSize, &len);
    if(ret ==-1)
    {
        perror("getsocket error.");
    }
    printf("Set send buf successful, SO_SNDBUF-%d\n\n\n", sendBufSize); 

    //configure pmmanager's addr
    memset(&pmmanager_addr, 0, sizeof(pmmanager_addr));
    pmmanager_addr.sun_family = AF_UNIX;
    strncpy(pmmanager_addr.sun_path, pmmanager, sizeof(pmmanager_addr)-1);
    len = sizeof(pmmanager_addr);

    int sendSize = 0;
    int i;
    for(i=1; i<=4; i++)
    {
        memset(tx_buf, '0', sizeof(tx_buf));
        sprintf(tx_buf, "send msg %d to pmmanager.", i);
        printf("%s, msg size - %d\n",tx_buf, sizeof(tx_buf));
        sendSize = sendto(pmapi_fd, tx_buf, sizeof(tx_buf), 0, (struct sockaddr*)&pmmanager_addr, len);
        if(sendSize == -1)
        {
            perror("sendto error.");
        }
        printf("Send message to pmmanager: %s\n\n\n", tx_buf);
    }
}

#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mman.h>

void sys_err(char *str)
{
    perror(str);
    exit(1);
}

int main(void)
{
    char *mem = NULL;
    int len = 0;

    int fd = open("hello244", O_RDWR|O_CREAT|O_TRUNC, 0644);
    if (fd < 0){
		sys_err("open error");
	}
        
    
	/*
	注意：由于mmap的参2是开辟文件大小的映射区，完美open时是一个新文件，
	此时大小为0，所以必须保证文件大小充足才能成功调用mmap开辟映射区。
	这就是下面两个方法的原因。
	方法1
    lseek(fd, 19, SEEK_END);	  //将文件下标移至19个字节
    write(fd, "\0", 1);			  //往文件写0，补充结尾。19+1=20个字节
	len = lseek(fd, 0, SEEK_END); //利用lseek的返回值获取当前文件下标即文件大小
	printf("The length of file = %d\n", len);
    */
	
	//方法2
	ftruncate(fd, 20);//该函数和lseek+write作用一样
	len = lseek(fd, 0, SEEK_END);
	
    mem = mmap(NULL, len, PROT_WRITE, MAP_SHARED, fd, 0);
    if (mem == MAP_FAILED){
		sys_err("mmap err: ");
	} 
	//此时可以直接关闭描述符，因为mem已经代替其作用
    close(fd);
	
	//使用mem(内存)对磁盘文件进行读写操作。
    strcpy(mem, "hello mmap");//写
    printf("%s\n", mem);//读

    if (munmap(mem, mem) < 0){
		sys_err("munmap");
	}

    return 0;
}

class Condition{
public:
    enum{
        PRIVATE=0;
        SHARED=1;
    };
    
    status_t wait(Mutex& mutex);
    status_t waitRelative(Mutex& mutex, nsecs_t reltime);
    void signal(); //条件满足时通知相应等待者
    void broadcast(); //条件满足时通知所有等待者
private:
    #if defined {HAVE_PTHREADS}
    	pthread_cond_t mCond;
    #else
    	void* mState;
    #endif
};

class Barrier{
public:
    inline Barrier():state(CLOSED){}
    inline ~Barrier(){}
    void open(){
        Mutex:: Autolock _l(lock);
        state=OPENED;
        cv.broadcast();
    }
    void close(){
        Mutex:: Autolock _l(lock);
        state=CLOSED;
    }
    void wait() const{
        Mutex:: Autolock _l(lock);
        while(state==CLOSED){
            cv.wait(lock);
        }
    }
private:
    enum {OPENED,CLOSED};
    mutable Mutex lock;
    mutable Condition cv;
    volatile int state;
}

class Autolock{
public:
    inline Autolock(Mutex& mutex): mLock(mutex){mLock.lock();}
    inline AUtolock(Mutex* mutex): mLock(*mutex){mLock.lock();}
    inline ~Autolock(){mLock.unlock();}
private:
    Mutex& mLock;
};

public static void main(String[] args) {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");

        // Install selective syscall interception
        AndroidOs.install();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();

        // Make sure TrustedCertificateStore looks in the right place for CA certificates
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);

        // Call per-process mainline module initialization.
        initializeMainlineModules();

        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();

        // Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.
        // It will be in the format "seq=114"
        long startSeq = 0;
        if (args != null) {
            for (int i = args.length - 1; i >= 0; --i) {
                if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
                    startSeq = Long.parseLong(
                            args[i].substring(PROC_START_SEQ_IDENT.length()));
                }
            }
        }
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }