Autor: Zen e a arte da programação de computadores
1. Introdução
Android é um sistema operacional de código aberto para dispositivos móveis, liderado pelo Google. É um sistema operacional móvel baseado em Linux, originalmente chamado Harmony OS. As principais versões atualmente no mercado incluem Nexus, Pixel, série Samsung Galaxy, série HTC One, MIUI, etc. Tem sido amplamente utilizado em vários dispositivos terminais, como smartphones, tablets e roteadores. Em 2017, o Google lançou o projeto AOSP (Android Open Source Project) baseado no código-fonte do Android.O código-fonte do sistema Android tornou-se uma comunidade aberta para os desenvolvedores modificarem e personalizarem.
Este artigo tomará a versão Android Nougat como objeto de pesquisa e realizará uma análise aprofundada dos conhecimentos básicos, modelo de programação, processo de desenvolvimento, componentes e características do sistema Android.
2. Explicação de conceitos e termos básicos
Esta seção apresentará brevemente algumas palavras-chave ou substantivos para facilitar a compreensão dos leitores.
- SDK (Kit de Desenvolvimento de Software): Kit de Desenvolvimento de Software (Kit de Desenvolvimento de Software), um ambiente de desenvolvimento e ferramentas fornecidas por fabricantes de hardware, desenvolvedores de software e licenciados a desenvolvedores para desenvolvimento, teste e publicação de software aplicativo. As principais funções fornecidas são: compilação, depuração, execução, análise, geração de documentos, etc.
2. API (Interface de Programação de Aplicativo): Interface de Programação de Aplicativo (API) é uma forma de chamar um programa de aplicativo para executar funções específicas por meio de programação de computador. As APIs são geralmente divididas em três categorias: APIs em nível de sistema, APIs em nível de estrutura e APIs em nível de biblioteca. Normalmente, as APIs em nível de sistema fornecem funções em nível de kernel do sistema, como sistemas operacionais, bancos de dados, redes, etc.; APIs em nível de estrutura fornecem aos desenvolvedores interfaces de desenvolvimento em nível de aplicativo, como Android Support Package ou Google Play Services Library, que encapsulam cada produto, respectivamente. Interface de desenvolvimento; API em nível de biblioteca fornece aos desenvolvedores a implementação de funções básicas, como renderização gráfica, processamento de imagens, codificação e decodificação, conexão de rede, cache de dados, etc., que podem ser implementadas por meio da API.
3. ART (Android Run-time for Transitions): Android Runtime (ART) é a Android Runtime Virtual Machine (VMO).É a versão otimizada do Dalvik VM do Google (a máquina virtual antes do ART), com o objetivo de agilizar o sistema. inicialização.Velocidade e consumo de memória reduzido. Embora o ART melhore o desempenho, ele também reduz a compatibilidade, porque o ART não pode suportar todos os conjuntos de instruções Dalvik e só pode reconhecer e traduzir alguns dos conjuntos de instruções Dalvik conhecidos.
4. Dalvik VM: a máquina virtual Dalvik foi originalmente um substituto para a máquina virtual Android no Android 1.5. Ela contém um interpretador de bytecode Java e executa bytecode na memória. Sua vantagem é a inicialização rápida, mas sua desvantagem é que ela ocupa memória. Também alto. O Dalvik VM foi gradualmente substituído pelo ART.
5. JVM (Java Virtual Machine): Java virtual machine é uma máquina virtual que pode executar qualquer programa Java em uma determinada máquina. A JVM compila todo o código Java em código nativo (linguagem de máquina) e então o executa.
6. C/C++ nativo: Essencialmente, ele chama as funções subjacentes fornecidas pelo sistema operacional. Como o próprio sistema operacional é escrito em C, ele pode ser executado em uma variedade de plataformas diferentes.
# 3. Explicação dos princípios básicos do algoritmo, etapas operacionais específicas e fórmulas matemáticas
Esta seção explicará as funções importantes e métodos de implementação do sistema Android em cada nível de três níveis: nível do sistema, nível da estrutura e nível da biblioteca.
Nível de sistema: API de nível de sistema cobre interfaces de kernel do sistema, sistema de arquivos, banco de dados, comunicação de rede, multimídia, câmera, GPS e outros módulos. Cada modelo de celular corresponde a uma versão do SDK. As interfaces entre os diferentes modelos de celular podem ser diferentes, mas geralmente são as mesmas. Como mencionado anteriormente, a API de nível de sistema fornece aos desenvolvedores uma interface de desenvolvimento de nível de kernel do sistema, portanto, os desenvolvedores precisam escolher a API de nível de sistema apropriada de acordo com a situação específica para atender às suas próprias necessidades.
Nível de estrutura: APIs em nível de estrutura, como Android Support Package e Google Play Services Library, fornecem interfaces de desenvolvimento em nível de aplicativo para que os desenvolvedores não precisem reinventar a roda. Entre eles, o Android Support Package fornece implementações compatíveis de algumas APIs em nível de sistema, como SharedPreferences, Content Provider, etc. O Google Play Services encapsula serviços de diferentes plataformas, como publicidade, mapas, etc., fornecendo aos desenvolvedores uma interface de desenvolvimento unificada.
Nível de biblioteca: API em nível de biblioteca, incluindo implementação de funções básicas, como renderização de gráficos, processamento de imagens, codificação e decodificação, conexão de rede, cache de dados, etc., que podem ser implementados por meio da API. Além disso, existem algumas bibliotecas de terceiros que oferecem mais funções, como a estrutura de carregamento de imagens Picasso, o gerenciador de layout RecyclerView, etc.
As etapas de operação específicas e fórmulas matemáticas são apresentadas abaixo.
1. Bitmap: Bitmap (Bitmap) é o conhecimento básico relacionado a imagens. Bitmap é uma matriz bidimensional, cada elemento representa um valor de pixel. Cada imagem é, na verdade, composta por vários "blocos de pixels" organizados em uma determinada ordem. Esses blocos de pixels são organizados em uma matriz bidimensional em ordem. Cada linha representa um par de dados de pixels, cada coluna representa uma coluna de dados de pixels e uma imagem Consiste nessas matrizes bidimensionais. Quando o programa desenha uma imagem, ele primeiro lê as informações de bitmap da imagem e, em seguida, usa as informações de bitmap para desenhar a imagem. Ao usar a aceleração de hardware para exibir uma imagem, o bitmap da imagem ainda será lido primeiro na memória, mas desta vez não é a CPU usada para exibição, mas a GPU para processamento. A GPU compactará a imagem e reduzirá o exibição. O tamanho da área é então enviado para a tela para exibição. Veja como obter o Bitmap:
2. OpenGL ES: OpenGL ES é uma extensão GLES do OpenGL e uma interface gráfica portátil e multiplataforma em nível de sistema baseada na especificação OpenGL. O objetivo do padrão OpenGL ES é permitir que os desenvolvedores usem aceleração de hardware diretamente sem usar drivers, ou seja, quando um dispositivo de hardware (como uma placa gráfica) suporta OpenGL ES, esta especificação pode ser implementada e usada diretamente em gráficos aplicativos.A capacidade do dispositivo de hardware a ser usado no aplicativo. No sistema Android é muito simples usar OpenGL ES para desenhar gráficos 2D e 3D. Basta converter os gráficos a serem exibidos em estruturas de dados desenháveis do OpenGL ES, como coordenadas de vértices, cores, coordenadas de textura, etc., e passá-los para o OpenGL ES para completar o desenho. Abaixo mostra um exemplo simples de desenho de um círculo:// 获取Activity的Window Window window = activity.getWindow(); // 从window中获取DecorView View decorView = window.getDecorView(); // 获取DecorView中的findViewById View view = decorView.findViewById(R.id.your_imageview); // 将ImageView转换为Bitmap Bitmap bitmap = ((BitmapDrawable)(view.getDrawable())).getBitmap();
private static final int POSITION_COMPONENT_COUNT = 2;
private static final int COLOR_COMPONENT_COUNT = 3;
private float[] vertexData = {
0.0f, 0.5f, 1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.0f, 0.0f, 1.0f
};
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertexData.length * 4);
byteBuffer.order(ByteOrder.nativeOrder());
FloatBuffer vertexBuffer = byteBuffer.asFloatBuffer();
vertexBuffer.put(vertexData);
vertexBuffer.position(0);
GL10 gl = getGL();
gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
gl.glVertexPointer(POSITION_COMPONENT_COUNT, GL10.GL_FLOAT, 0, vertexBuffer);
gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
gl.glColorPointer(COLOR_COMPONENT_COUNT, GL10.GL_FLOAT, 0, vertexBuffer);
gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
gl.glDrawArrays(GL10.GL_TRIANGLES, 0, vertexData.length / POSITION_COMPONENT_COUNT);
gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
gl.glDisableClientState(GL10.GL_COLOR_ARRAY);
}
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
super.surfaceChanged(holder, format, width, height);
mWidth = width;
mHeight = height;
Log.d("TAG", "width=" + width + ",height=" + height);
}
- Handler: mecanismo de mensagem (Handler). No sistema Android, Handler é uma fila de mensagens usada para processar mensagens, eventos e tarefas. A função do Handler é em grande parte dissociar a lógica de negócios complexa do thread da UI. As mensagens são armazenadas por meio de MessageQueue (fila de mensagens) e o Handler consome mensagens. Quando uma mensagem ocorre, uma mensagem é primeiro armazenada na fila de mensagens por meio do método sendMessage() do manipulador e, em seguida, a mensagem é processada por meio do método handleMessage() do manipulador. Após a mensagem ser armazenada na fila, ela será executada pelo despacho da fila de mensagens (método dispatchMessage()). Aqui está um exemplo de uso simples:
// 创建Handler
Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case MSG_WHAT:
break;
default:
super.handleMessage(msg);
break;
}
}
};
// 发送消息
Message message = new Message();
message.what = MSG_WHAT;
handler.sendMessage(message);
- Multiprocesso: Mecanismo multiprocesso (MultiProcess). O mecanismo multiprocesso fornecido pelo sistema Android é usado principalmente para resolver o problema de competição de recursos quando vários aplicativos compartilham os mesmos dados. O sistema Android coloca diferentes aplicações em diferentes processos, evitando problemas de competição de recursos causados pelo compartilhamento de dados entre múltiplas aplicações e melhorando a estabilidade do sistema. Cada processo possui sua própria máquina virtual e espaço de pilha independente, sem interferir entre si, para que possam ser isolados entre si e evitar o problema de recursos se afetarem. Além disso, o sistema Android fornece um método de comunicação multiprocesso mais flexível por meio do mecanismo Binder IPC (comunicação entre processos). A seguir apresentamos o processo de criação de vários processos e alguns cuidados:
/**
* 创建新进程
*/
public class MyService extends Service {
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
startOtherProcess();
}
/**
* 启动其他进程
*/
private void startOtherProcess() {
Intent intent = new Intent(this, OtherProcessService.class);
String processName = "other_process";
ProcessBuilder builder = new ProcessBuilder();
builder.command("/system/bin/sh")
.redirectErrorStream(true)
.redirectInput(Redirect.PIPE)
.redirectOutput(Redirect.PIPE)
.directory(".")
.argument("-c")
.argument("exec app_process "
+ "/data/app/" + getPackageName() + "-1/"
+ "lib/" + processName + "/"
+ " --nice-name=" + processName).redirectError();
try {
Log.i("MyService", "start other process");
Process process = builder.start();
OutputStream outputStream = process.getOutputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(
process.getInputStream()));
String line = "";
while (!isInterrupted()) {
if (line!= null &&!"".equals(line)) {
Log.i("MyService", line);
}
line = reader.readLine();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
Log.i("MyService", "end other process");
}
}
}
/**
* 服务端实现进程通信
*/
public class OtherProcessService extends Service {
private static final String TAG = "OtherProcessService";
@Nullable
@Override
public IBinder onBind(Intent intent) {
return binder;
}
private IBinder.DeathRecipient deathRecipient = new IBinder.DeathRecipient() {
@Override
public void binderDied() {
Log.e(TAG, "binder died");
}
};
private Binder binder = new Binder();
@Override
public void onCreate() {
registerBinder();
startForegroundService();
}
private void registerBinder() {
try {
LocalBroadcastManager manager = LocalBroadcastManager.getInstance(this);
IntentFilter filter = new IntentFilter(ACTION_BINDER_DIED);
manager.registerReceiver(broadcastReceiver, filter);
} catch (Exception e) {
e.printStackTrace();
}
}
BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Log.i(TAG, "receive action:" + intent.getAction());
}
};
private void startForegroundService() {
Intent service = new Intent(this, ForegroundService.class);
bindService(service, connection, Context.BIND_AUTO_CREATE);
}
Connection connection = new Connection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.i(TAG, "connected to foreground service");
try {
service.linkToDeath(deathRecipient, 0);
IInterface iInterface = IInterface.Stub.asInterface(service);
Method method = iInterface.getClass().getMethod("sayHelloFromOtherProcess");
method.invoke(iInterface);
unbindService(this);
} catch (RemoteException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.i(TAG, "disconnected from foreground service");
}
};
}
/**
* 客户端接口定义
*/
interface IInterface extends IBinder {
String DESCRIPTOR = "com.example.IInterface";
String sayHelloFromOtherProcess();
}
/**
* 客户端调用服务端接口
*/
public class Client implements IServiceCallback{
private static final String TAG = "Client";
private IServiceProxy proxy;
@Override
public void onResult(String result) {
Log.i(TAG, "result:" + result);
}
@Override
public void onError(String errorMsg) {
Log.i(TAG, "error:" + errorMsg);
}
@Override
public void connect() {
proxy = new IServiceProxy();
proxy.setCallback(this);
proxy.connect(getContext(), OtherProcessService.DESCRIPTOR);
}
@Override
public void disconnect() {
proxy.disconnect();
}
@Override
public void callService() throws RemoteException {
IInterface stub = IService.Stub.asInterface((IBinder) proxy.getService());
String result = stub.sayHelloFromOtherProcess();
Log.i(TAG, "call result:" + result);
}
}
O exemplo acima descreve como se comunicar entre dois processos diferentes, onde o primeiro processo é o servidor e o segundo processo é o cliente. O cliente primeiro cria uma classe proxy e depois chama o método do servidor por meio da classe proxy. O servidor retorna o resultado após receber a solicitação do cliente.
Na prática, os mecanismos Messenger e AIDL podem ser usados para implementar a comunicação entre processos. Messenger é um mecanismo IPC leve, adequado para cenários IPC frequentes e oferece suporte a vários processos. AIDL (Android Interface Definition Language) é uma linguagem para definição de interfaces no desenvolvimento Android. AIDL pode ser usado para definir a interface de comunicação entre o servidor e o cliente. A seguir apresentamos dois mecanismos IPC comumente usados na prática:
- Messenger: Messenger é um mecanismo IPC leve, adequado para cenários com IPC frequente. Assim como o Binder, o Messenger também é implementado com base no Binder. Ao usar o Messenger, o servidor e o cliente precisam implementar a mesma interface e declarar seus nomes de interface no arquivo de manifesto.
<receiver android:name=".MessengerService" >
<!-- Export service to remote clients -->
<intent-filter>
<action android:name="android.intent.action.MESSENGER_SERVICE"/>
</intent-filter>
</receiver>
<service
android:name=".MessengerService">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
</intent-filter>
</service>
public class MessengerService extends Service {
private static final String TAG = "MessengerService";
private Messenger messenger = new Messenger(new IncomingHandler());
@Override
public void onCreate() {
Log.d(TAG,"onCreate()");
}
@Override
public IBinder onBind(Intent intent) {
Log.d(TAG,"onBind()");
return messenger.getBinder();
}
class IncomingHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_WHAT:
Bundle bundle = msg.getData();
int arg1 = bundle.getInt("arg1");
int arg2 = bundle.getInt("arg2");
Log.d(TAG,"arg1="+arg1+",arg2="+arg2);
replyToClient(MSG_REPLY);
break;
case MSG_REPLY:
Log.d(TAG,"reply received");
break;
default:
super.handleMessage(msg);
break;
}
}
}
}
public class MessengerClient {
private static final String TAG = "MessengerClient";
private Messenger messenger = new Messenger(new OutgoingHandler());
public void sendMessage() {
Message msg = Message.obtain(null, MSG_WHAT);
Bundle bundle = new Bundle();
bundle.putInt("arg1",100);
bundle.putInt("arg2",200);
msg.setData(bundle);
msg.replyTo = messenger;
messenger.send(msg);
}
class OutgoingHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_REPLY:
Log.d(TAG,"receive reply");
break;
default:
super.handleMessage(msg);
break;
}
}
}
}
As duas classes acima constituem uma aplicação simples do Messenger. O cliente usa o Messenger para enviar uma mensagem ao servidor através do Binder, e o servidor responde após receber a mensagem.
2. AIDL: AIDL (Android Interface Definition Language) é uma linguagem para definir interfaces no desenvolvimento Android. AIDL pode ser usado para definir a interface de comunicação entre o servidor e o cliente. A sintaxe AIDL é semelhante às interfaces Java e os métodos de interface podem ser mapeados para quatro tipos de comandos IPC:
a.IN: parâmetros de entrada, passados do servidor para o cliente.
b. OUT: Parâmetros de saída, passados do cliente para o servidor.
c. STREAM: Os parâmetros de streaming são passados ao cliente lado a lado.
d.REMOTE: chamada remota, o cliente chama a interface do servidor.
O método de usar AIDL para definir uma interface é o seguinte:
- Defina uma interface para o servidor, como IFooService.aidl:
package com.example;
interface IFooService {
int add(int a, int b) throws RemoteException;
int minus(int a, int b) throws RemoteException;
String echo(String str) throws RemoteException;
}
- Defina uma interface de retorno de chamada para o cliente, como IFooCallback.aidl:
package com.example;
import com.example.IProgressListener;
interface IFooCallback extends IProgressListener.Stub {
void onSuccess(String result);
void onFailure(String reason);
}
- Defina a classe de retorno de chamada da interface do lado do servidor para o cliente, como FooCallback.java:
package com.example;
import android.os.Parcel;
import android.os.RemoteException;
public abstract class FooCallback extends IProgressListener.Stub {
@Override
public void progress(final Parcel data) throws RemoteException {
final Parcelable parcelable = data.readParcelable(getClass().getClassLoader());
getActivity().runOnUiThread(new Runnable() {
@Override
public void run() {
updateProgress((Long) parcelable);
}
});
}
public abstract void updateProgress(long progress);
public abstract Activity getActivity();
}
- Implemente Activity ou Fragment do lado do cliente, como MainActivity.java:
package com.example;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;
import android.support.v4.app.FragmentTransaction;
import android.util.Log;
import android.widget.TextView;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
public class MainActivity extends BaseActivity {
private TextView mTextView;
private IFooService fooService;
private IFooCallback fooCallback;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTextView = (TextView) findViewById(R.id.text_view);
FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
transaction.replace(R.id.container, MainFragment.newInstance()).commitAllowingStateLoss();
initAidl();
callService();
}
private void initAidl() {
ComponentName componentName = new ComponentName(this, "com.example.IFooService");
fooService = IFooService.Stub.asInterface(
this.getSystemService(Context.BIND_PACKAGE_SERVICE));
fooCallback = new FooCallback() {
@Override
public void updateProgress(long progress) {
mTextView.setText("" + progress);
}
@Override
public Activity getActivity() {
return MainActivity.this;
}
};
}
private void callService() {
try {
Thread.sleep(3000);
int ret = fooService.add(1, 2);
Log.d("MainActicity", "" + ret);
ret = fooService.minus(10, 5);
Log.d("MainActicity", "" + ret);
String str = fooService.echo("hello world!");
Log.d("MainActicity", "" + str);
Parcel data = Parcel.obtain();
data.writeLong(100);
fooService.progress(data);
data.recycle();
} catch (InterruptedException | RemoteException | IOException | ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
e.printStackTrace();
}
}
}
- Registre o Broadcast Receiver do lado do servidor no arquivo de manifesto. Por exemplo, registre o Broadcast Receiver no arquivo de manifesto:
<receiver android:name=".AidlDemoBroadcastReceiver">
<intent-filter>
<action android:name="com.example.FOOBAR_BROADCAST"/>
</intent-filter>
</receiver>
- O servidor recebe a transmissão do cliente, analisa a mensagem e retorna o resultado. Por exemplo, o servidor define um receptor de transmissão em seu próprio arquivo de manifesto:
<service android:name=".AidlDemoService">
<intent-filter>
<action android:name="com.example.FOO_SERVICE"/>
</intent-filter>
</service>
Quando o cliente recebe a notificação, ele chama a interface de serviço remota para processar a mensagem. Depois que o servidor concluir o processamento, ele enviará uma mensagem de difusão.
5. Tendências e desafios futuros do desenvolvimento
Este artigo apresenta alguns conceitos básicos, modelos de programação, processos de desenvolvimento, componentes e recursos do sistema Android e discorre sobre os princípios básicos e etapas operacionais específicas do sistema Android com base em casos específicos. No futuro, à medida que o ecossistema Android avança, ainda há muitos lugares que valem a pena explorar e aprender. Compartilhe algumas opiniões abaixo.
- Aceleração de hardware: o Google está planejando oferecer suporte total ao OpenGL ES 3.0. Isso ajuda os desenvolvedores a aproveitar melhor a aceleração de hardware.
- Segurança de rede: As atuais permissões de acesso à rede do sistema Android não são refinadas o suficiente e os aplicativos relacionados à segurança dependem do sistema Android de caixa preta. O Google está pesquisando novos mecanismos relacionados à segurança de rede, na esperança de melhorar a proteção da segurança de rede do sistema Android.
- Dinâmico: o Google está tentando fornecer aos aplicativos Android recursos de implantação dinâmica por meio de um sistema de componentes abertos, que pode realizar atualizações on-line, atualizações dinâmicas, migração e outras funções.
- VR/AR: Nos últimos anos, a escala de hardware e a inovação tecnológica no campo VR/AR promoveram rapidamente o desenvolvimento de toda a indústria, e o Google também está explorando ativamente a cooperação nesta área.
- Sistema operacional: já existem alguns sistemas embarcados de código aberto no mercado que podem executar sistemas Android e também servir como sistemas desktop clientes. Através da integração profunda, o sistema operacional de código aberto pode ser profundamente integrado ao sistema Android e aproveitar ao máximo suas respectivas vantagens.