Android has a large community of developers writing applications (“apps”) that extend the functionality of the devices. Developers write primarily in a customized version of Java.[11] Apps can be downloaded from third-party sites or through online stores such as Google Play (formerly Android Market), the app store run by Google.

http://android.yaohuiji.com/about

http://www.android-study.com/

推荐几个比较好的android学习网站：

1．www.android.com：这是android的官网

2．www.android123.com.cn：android开发网

3．www.javaeye.com/groups/tag/Android: 一个开放的android交流平台

4．http://ophone.csdn.net/：ophone csdn专区

5．http://www.ophonesdn.com/：Ophone开发者官网，版主往往是Ophone SDK的开发成员。

6．http://www.3gdci.com/:东方尚智3G数字学院，从这里也不乏找到一些好文章。

7．http://www.jollen.org/blog/android_os/: jollen的博客，很喜欢其中的文章

http://answers.oreilly.com/topic/1366-how-to-write-to-an-avi-file-with-opencv/

or you can use ffmpeg.

https://wiki.ubuntu.com/PbuilderHowto

1. Get latest linux kernel code from kernel.org
$ cd /tmp
$ wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-x.y.z.tar.bz2
x.y.z is the version number.

2. Extract tar (.tar.bz3) file

Type the following command:
# tar -xjvf linux-2.6.25.tar.bz2 -C /usr/src
# cd /usr/src

3. Configure kernel
make sure you have gcc installed. Do the following if the lib is missing.

apt-get install libncurses*
apt-get install build-essential libncurses5-dev

Now you can start kernel configuration by typing any one of the command:

$ make menuconfig – Text based color menus, radiolists & dialogs. This option also useful on remote server if you wanna compile kernel remotely. The following are the same thing, you just gonna file one,configure the kernel tree and make.

$ make xconfig – X windows (Qt) based configuration tool, works best under KDE desktop
$ make gconfig – X windows (Gtk) based configuration tool, works best under Gnome Dekstop.

4. Compile kernel
Start compiling to create a compressed kernel image, enter:
$ make

Start compiling to kernel modules:
$ make modules

Install kernel modules (become a root user, use su command):
$ su -
# make modules_install

5 Install kernel

So far we have compiled kernel and installed kernel modules. It is time to install kernel itself.
# make install

It will install three files into /boot directory as well as modification to your kernel grub configuration file:

System.map-2.6.25
config-2.6.25
vmlinuz-2.6.25

6: Create an initrd image

Type the following command at a shell prompt:
# cd /boot
# mkinitrd -o initrd.img-2.6.25 2.6.25

initrd images contains device driver which needed to load rest of the operating system later on. Not all computer requires initrd, but it is safe to create one.

7. Modify Grub configuration file – /boot/grub/menu.lst

Open file using vi:
# vi /boot/grub/menu.lst

title Debian GNU/Linux, kernel 2.6.25 Default
root (hd0,0)
kernel /boot/vmlinuz root=/dev/hdb1 ro
initrd /boot/initrd.img-2.6.25
savedefault
boot

Remember to setup correct root=/dev/hdXX device. Save and close the file. If you think editing and writing all lines by hand is too much for you, try out update-grub command to update the lines for each kernel in /boot/grub/menu.lst file. Just type the command:

# update-grub

8 : Reboot computer and boot into your new kernel

Just issue reboot command:
# reboot

1. ISO C++ forbids in-class initialization of non-const static member. You have to make it static.

For static var defined in .h file, you have to define it in the .cpp file
class:: var.

3. Any static member function defined in .h, in .cpp file, you do not put static keyword when you implement them.

Examples:

non-const static var,
//b.h
class B
{
public:
void f();
static void t();

private:
const static int count=1;
int c;
};

//b.cpp

#include “b.h”
#include
using namespace std;

void B::f(){
cout<<"f()"< cout< }

void B::t(){
cout<<"t()"< cout< }

int main()
{
B b;
b.f();
b.t();
B::t();
}

Take the const off, the following compilation fails, because, it would expect you initialize it in implementation not in the declaration. This make class clean. Why const static is ok? Because you can think it is a constant.

class B
{
public:
void f();
static void t();

private:
static int count=1;
int c;
};

error:b.h:8: error: ISO C++ forbids in-class initialization of non-const static member ‘count’

Now delete the assignment of count, you get another error.

xiaofengmaclap:~ wolfram$ g++ b.cpp -o b.exe
Undefined symbols:
"B::count", referenced from:
__ZN1B5countE$non_lazy_ptr in ccviRxVn.o
(maybe you meant: __ZN1B5countE$non_lazy_ptr)
ld: symbol(s) not found
collect2: ld returned 1 exit status

What you need to do is to declare the static count in .cpp file.

#include
using namespace std;

int B::count=1;

void B::f(){
cout<<"f()"< cout< }

void B::t(){
cout<<"t()"< cout< }

int main()
{
B b;
b.f();
b.t();
B::t();
}

Usually it is initialize in the constructor,

xiaofengmaclap:~ wolfram$ vi b.cpp

//b.cpp
#include "b.h"
#include
using namespace std;

int B::count;

B::B()
{
B::count=1;
}

void B::f(){
cout<<"f()"< cout< }

void B::t(){
cout<<"t()"< cout< }

Not to say for int c, initialization in class is forbidden too.

non-static function can call both non-static variable and static variable.
static function can only call static variable.

The following example shows it,

//b.h
class B
{
public:
B();
void f();
static void t();

private:
static int count;
int c;
};

//b.cpp
#include "b.h"
#include
using namespace std;

int B::count;

B::B()
{
B::count=1;
this->c=2;
}

void B::f(){
cout<<“f()”< cout< cout< }

void B::t(){
cout<<“t()”< cout< //cout< }

int main()
{
B b;
b.f();
b.t();
B::t();
}

Here is a working example,

#include
using std::cout;
using std::endl;

int main()
{
Test Obj;
Obj.my_func(Obj.callback_func);
}


How to pass arguments to callback function?

#include

template< typename A, typename B >
void foo( A a, B b )
{
a( b );
}

void boo1( const int p )
{
std::cout<<"boo( " << p << " )" << std::endl;
}

void boo2( const std::string p )
{
std::cout<<"boo( " << p << " )" << std::endl;
}

int main()
{
foo( boo1, 3 );
foo( boo2, "abc" );
}

or,

template
void function(void (*handler)(T), T variable)
{
handler(variable);
}

The main features of a driver are:

There are four types of drivers: character drivers, block drivers, terminal drivers and streams. Character drivers transmit information from the user to the device (or vice versa) byte per byte. Two examples are the printer, /dev/lp, and the memory (yes, the memory is also a device), /dev/mem.

Block drivers transmit information block per block. This means that the incoming data (from the user or from the device) are stored in a buffer until the buffer is full. When this occurs, the buffer content is physically sent to the device or to the user. This is the reason why all the printed messages do not appear in the screen when a user program crashes (the messages in the buffer were lost), or the floppy drive light does not always turn on when the user writes to a file. The clearest examples of this type of driver are disks: floppy disks (/dev/fd0), IDE hard disks (/dev/hda) and SCSI hard disks (/dev/sd1).

Terminal drivers (see Figure 4) constitute a special set of character drivers for user communication. For example, command tools in an open windows environment, an X terminal or a console, are devices which require special functions, e.g., the up and down arrows for a command buffer manager or tabbing in the bash shell. Examples of block drivers are /dev/tty0 or /dev/ttya (a serial port). In both cases the kernel includes special routines, and the driver special procedures, to cope with all particular features.

Streams are the youngest drivers (see Figure 5) and are designed for very high speed data flows. Both the kernel and the driver include several protocol layers. The best example of this type is a network driver.

As we have said, a driver is a piece of a program. It is composed of a set of C functions, some of which are mandatory. For example, for a printer device, some typical functions only called by the kernel, may be:

Some additional functions are available for particular applications, like *_lseek(), *_readdir(), *_select() and *_mmap(). You may find more information about them in Michael Johnson’s Hacker’s Guide (see Resources).

Do I Really Need to Write a Driver?

There are several reasons for writing our own device driver:

Conversely, there are also several reasons for not writing our own driver:

However, both the directory structure and the driver interface with the kernel are OS dependent. Indeed small changes may appear from one version or release to the next. For example, several things changed from Linux 1.2.x to Linux 2.0.x, such as the prototypes of the driver functions, the kernel configuration method and the Makefiles for kernel compilation.

The mobile platform is composed of a set of wheels coupled with two motors (the drive and the steer), a set of 24 sonars which act as proximity sensors for obstacle detection and a set of bumpers which detect collisions. We need to implement a driver with, at least, the following services (init, open and release are mandatory):

The go to home service allows the user to stop the wheels at an initial position which is always the same (0 degrees). The incoming values from sonars and encoders, as well as the velocity commands, might be part of the main loop of the control program of the robot.

Returning to the initial scheme (Figure 1), the device is the MRV-4 robot, the hardware interface is the motor/sonar card, the source file of the driver will be mrv4.c, the new kernel we will generate will be vmlinuz, the user program for kernel testing will be mrv4test.c and the device will be /dev/mrv4

General Programming Considerations

To build a driver, these are the steps to follow:

The directory structure of the Linux source files can be described as follows: the /usr/src contains subdirectories such as /xview and /linux. Inside the /linux directory, the different parts of the kernel are classified into subdirectories: init, kernel, ipc, drivers, etc. The directory /usr/src/linux/drivers/ contains the driver sources, classified into categories such as block, char, net, etc.

Another interesting directory is /usr/include, where the main header files, such as stdio.h, are located. It contains two special subdirectories:

The first task when programming the source files of a driver is to select a name to identify it uniquely, such as hd, sd, fd, lp, etc. In our case we decided to use mrv4. Our driver is going to be a character driver, so we will write the source into the file /usr/src/linux/drivers/char/mrv4.c, and its header into /usr/include/linux/mrv4.h.

The second task is to implement the driver I/O functions. In our case, mrv4_open(), mrv4_read(), mrv4_write(), mrv4_ioctl() and mrv4_release().

Special care must be taken when programming the driver because of the following limitations:

The OS functions supported at kernel level are, of course, only those functions programmed inside it:

Detailed information on these functions is given in Johnson’s Guide (see Resources) or even inside the kernel source files.

Low-Level Programming

Access to the hardware interface (the card) is provided through low-memory addressing. The I/O registers of the card, where we can read/write information, are physically connected to memory addresses of the PC (i.e., ports). For instance, the motor/sonar card of the MRV-4 mobile robot is associated with the address 0x1b0. Sixteen registers are used in this card, so the port map includes addresses from 0x1b0 to 0x1be. A typical list of port addressing is shown in Table 1.:

Table 1. Typical Port Addresses

Ref:

http://www.linuxjournal.com/article/2476?page=0,1

#include <iostream>
using namespace std;

class A
{
public:
virtual void f()=0;
};

class B: public A
{
public:
using A::f;

void f(int)
{
cout<<”B’s f(int)”;
}

void f()
{}
};

int main()
{
B b;
// b.f();
b.f(1);
}

Or, if A does not have pure virtual function but normal pure function.

A must implement virtual function or leave it empty implementation. Or it will not compile. It does not matter B implements its own or not.

#include <iostream>
using namespace std;

class A
{
public:
virtual void f(){};  //without {} it will not compile
};

class B: public A
{
public:
using A::f;

void f(int)
{
cout<<”B’s f(int)”;
}
};

int main()
{
B b;
// b.f();
b.f(1);
}

Now let us take out A::f, the compilation will fail.  The above program overloads the function inherited from the base class.

sub daemonize {
use POSIX;
POSIX::setsid or die “setsid: $!”;
my $pid = fork ();
if ($pid < 0) {
die "fork: $!";
}
elsif ($pid) {
exit 0;
}
chdir "/";
umask 0;
foreach (0 .. (POSIX::sysconf (&POSIX::_SC_OPEN_MAX) || 1024))
{
POSIX::close $_
}
open (STDIN, " open (STDOUT, ">/dev/null”);
open (STDERR, “>&STDOUT”);
}

2.
The easiest way is to use Proc::Daemon.

#!/usr/bin/perl

use strict;
use warnings;
use Proc::Daemon;

Proc::Daemon::Init;

my $continue = 1;
$SIG{TERM} = sub { $continue = 0 };

while ($continue) {
#do stuff
}

Alternately you could do all of the things Proc::Daemon does:

1. Fork a child and exits the parent process.
2. Become a session leader (which detaches the program from the controlling terminal).
3. Fork another child process and exit first child. This prevents the potential of acquiring a controlling terminal.
4. Change the current working directory to “/”.
5. Clear the file creation mask.
6. Close all open file descriptors.

Ref:

http://stackoverflow.com/questions/766397/how-can-i-run-a-perl-script-as-a-system-daemon-in-linux

http://www.andrewault.net/2010/05/27/creating-a-perl-daemon-in-ubuntu/

class DeviceException : public std::exception
{
public:
DeviceException();
~DeviceException() throw();

//TODO stub in exception methods
//TODO add ability to embed file and line number info into exception
};

http://www.parashift.com/c++-faq-lite/strange-inheritance.html#faq-23.10

http://www.daniweb.com/software-development/cpp/threads/114299/undefined-reference-to-vtable-for-