一
应用清单文件

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myapp"
    android:versionCode="1"
    android:versionName="1.0" >
    ...
</manifest>

<manifest ... >
    <application ... >
        <activity android:name="com.example.myapp.MainActivity" ... >
        </activity>
    </application>
</manifest>

<manifest package="com.example.myapp" ... >
    <application ... >
        <activity android:name=".MainActivity" ... >
            ...
        </activity>
    </application>
</manifest>

<manifest ... >
    <uses-permission android:name="android.permission.SEND_SMS"/>
    ...
</manifest>

<manifest ... >
    <uses-feature android:name="android.hardware.sensor.compass"
                  android:required="true" />
    ...
</manifest>

<intent-filter ... >
    <action android:name="android.intent.action.EDIT" />
    <action android:name="android.intent.action.INSERT" />
    <action android:name="android.intent.action.DELETE" />
    ...
</intent-filter>

"@[package:]type/name"

<activity android:icon="@drawable/smallPic" ... >

"?[package:]type/name"

二
四大组件

<activity android:allowEmbedded=["true" | "false"]
          android:allowTaskReparenting=["true" | "false"]
          android:alwaysRetainTaskState=["true" | "false"]
          android:autoRemoveFromRecents=["true" | "false"]
          android:banner="drawable resource"
          android:clearTaskOnLaunch=["true" | "false"]
          android:colorMode=[ "hdr" | "wideColorGamut"]
          android:configChanges=["mcc", "mnc", "locale",
                                 "touchscreen", "keyboard", "keyboardHidden",
                                 "navigation", "screenLayout", "fontScale",
                                 "uiMode", "orientation", "density",
                                 "screenSize", "smallestScreenSize"]
          android:directBootAware=["true" | "false"]
          android:documentLaunchMode=["intoExisting" | "always" |
                                  "none" | "never"]
          android:enabled=["true" | "false"]
          android:excludeFromRecents=["true" | "false"]
          android:exported=["true" | "false"]
          android:finishOnTaskLaunch=["true" | "false"]
          android:hardwareAccelerated=["true" | "false"]
          android:icon="drawable resource"
          android:immersive=["true" | "false"]
          android:label="string resource"
          android:launchMode=["standard" | "singleTop" |
                              "singleTask" | "singleInstance" | "singleInstancePerTask"]
          android:lockTaskMode=["normal" | "never" |
                              "if_whitelisted" | "always"]
          android:maxRecents="integer"
          android:maxAspectRatio="float"
          android:multiprocess=["true" | "false"]
          android:name="string"
          android:noHistory=["true" | "false"]  
          android:parentActivityName="string" 
          android:persistableMode=["persistRootOnly" | 
                                   "persistAcrossReboots" | "persistNever"]
          android:permission="string"
          android:process="string"
          android:relinquishTaskIdentity=["true" | "false"]
          android:resizeableActivity=["true" | "false"]
          android:screenOrientation=["unspecified" | "behind" |
                                     "landscape" | "portrait" |
                                     "reverseLandscape" | "reversePortrait" |
                                     "sensorLandscape" | "sensorPortrait" |
                                     "userLandscape" | "userPortrait" |
                                     "sensor" | "fullSensor" | "nosensor" |
                                     "user" | "fullUser" | "locked"]
          android:showForAllUsers=["true" | "false"]
          android:stateNotNeeded=["true" | "false"]
          android:supportsPictureInPicture=["true" | "false"]
          android:taskAffinity="string"
          android:theme="resource or theme"
          android:uiOptions=["none" | "splitActionBarWhenNarrow"]
          android:windowSoftInputMode=["stateUnspecified",
                                       "stateUnchanged", "stateHidden",
                                       "stateAlwaysHidden", "stateVisible",
                                       "stateAlwaysVisible", "adjustUnspecified",
                                       "adjustResize", "adjustPan"] >   
    ...
</activity>

    
<manifest ... >
      <application ... >
          <activity android:name=".ExampleActivity" />
          ...
      </application ... >
      ...
    </manifest >

    
<activity android:name=".ExampleActivity" android:icon="@drawable/app_icon">
        <intent-filter>
            <action android:name="android.intent.action.SEND" />
            <category android:name="android.intent.category.DEFAULT" />
            <data android:mimeType="text/plain" />
        </intent-filter>
    </activity>

    
val sendIntent = Intent().apply {
        action = Intent.ACTION_SEND
        type = "text/plain"
        putExtra(Intent.EXTRA_TEXT, textMessage)
    }
    startActivity(sendIntent)

    
<manifest>
    <activity android:name="...."
       android:permission=”com.google.socialapp.permission.SHARE_POST”
    />

    
<manifest>
       <uses-permission android:name="com.google.socialapp.permission.SHARE_POST" />
    </manifest>

onStartCommand()

onBind()

onCreate()

onDestroy()

<manifest ... >
  ...
  <application ... >
      <service android:name=".ExampleService" />
      ...
  </application>
</manifest>

<service android:description="string resource"
         android:directBootAware=["true" | "false"]
         android:enabled=["true" | "false"]
         android:exported=["true" | "false"]
         android:foregroundServiceType=["camera" | "connectedDevice" |
                                        "dataSync" | "location" | "mediaPlayback" |
                                        "mediaProjection" | "microphone" | "phoneCall"]
         android:icon="drawable resource"
         android:isolatedProcess=["true" | "false"]
         android:label="string resource"
         android:name="string"
         android:permission="string"
         android:process="string" >
    ...
</service>

public class HelloIntentService extends IntentService {
  /**
   * 必须提供一个构造函数，并且必须调用super <code><a href="/reference/android/app/IntentService.html#IntentService(java.lang.String)">IntentService(String)</a></code>
   * 构造函数，并为工作线程指定一个名称。
   */
  public HelloIntentService() {
      super("HelloIntentService");
  }
  /**
   * IntentService会在默认的工作线程中调用此方法，并传入启动服务的Intent。
   * 当此方法返回时，IntentService会根据需要停止服务。
   */
  @Override
  protected void onHandleIntent(Intent intent) {
      // 通常在这里会执行一些工作，比如下载文件。
      // 这个示例中，我们只是睡眠5秒钟。
      try {
          Thread.sleep(5000);
      } catch (InterruptedException e) {
          // 恢复中断状态。
          Thread.currentThread().interrupt();
      }
  }
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
    return super.onStartCommand(intent,flags,startId);
}

public class HelloService extends Service {
  private Looper serviceLooper;
  private ServiceHandler serviceHandler;
  // 从线程接收消息的Handler
  private final class ServiceHandler extends Handler {
      public ServiceHandler(Looper looper) {
          super(looper);
      }
      @Override
      public void handleMessage(Message msg) {
          // 通常在这里会执行一些工作，比如下载文件。
          // 这个示例中，我们只是睡眠5秒钟。
          try {
              Thread.sleep(5000);
          } catch (InterruptedException e) {
              // 恢复中断状态。
              Thread.currentThread().interrupt();
          }
          // 使用startId停止服务，以确保我们不会在处理其他任务时停止服务
          stopSelf(msg.arg1);
      }
  }
  @Override
  public void onCreate() {
    // 启动运行服务的线程。注意，我们创建了一个单独的线程，因为服务通常在进程的主线程中运行，
    // 我们不希望阻塞主线程。我们还将其设置为后台优先级，以防止CPU密集型工作影响我们的UI。
    HandlerThread thread = new HandlerThread("ServiceStartArguments",
            Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    // 获取HandlerThread的Looper，并将其用于我们的Handler
    serviceLooper = thread.getLooper();
    serviceHandler = new ServiceHandler(serviceLooper);
  }
  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
      Toast.makeText(this, "服务启动中", Toast.LENGTH_SHORT).show();
      // 对于每个启动请求，发送一条消息来启动一个任务，并传递startId，
      // 这样我们在完成任务后就知道要停止哪个请求
      Message msg = serviceHandler.obtainMessage();
      msg.arg1 = startId;
      serviceHandler.sendMessage(msg);
      // 如果我们被杀死，返回之后重新启动
      return START_STICKY;
  }
  @Override
  public IBinder onBind(Intent intent) {
      // 我们不提供绑定，所以返回null
      return null;
  }
  @Override
  public void onDestroy() {
    Toast.makeText(this, "服务已完成", Toast.LENGTH_SHORT).show();
  }
}

Intent notificationIntent = new Intent(this, ExampleActivity.class);
PendingIntent pendingIntent =
        PendingIntent.getActivity(this, 0, notificationIntent, 0);
Notification notification =
          new Notification.Builder(this, CHANNEL_DEFAULT_IMPORTANCE)
    .setContentTitle(getText(R.string.notification_title))
    .setContentText(getText(R.string.notification_message))
    .setSmallIcon(R.drawable.icon)
    .setContentIntent(pendingIntent)
    .setTicker(getText(R.string.ticker_text))
    .build();
startForeground(ONGOING_NOTIFICATION_ID, notification);

public class ExampleService extends Service {
    int startMode;       // 表示服务被杀死时的行为方式
    IBinder binder;      // 用于与绑定客户端通信的接口
    boolean allowRebind; // 表示是否应该使用onRebind方法
    @Override
    public void onCreate() {
        // 服务被创建
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 服务正在启动，由于调用了startService()方法
        return startMode;
    }
    @Override
    public IBinder onBind(Intent intent) {
        // 有客户端通过bindService()方法绑定到服务
        return binder;
    }
    @Override
    public boolean onUnbind(Intent intent) {
        // 所有客户端都通过unbindService()方法取消了绑定
        return allowRebind;
    }
    @Override
    public void onRebind(Intent intent) {
        // 一个客户端通过bindService()方法重新绑定到服务，之前已经调用了onUnbind()方法
    }
    @Override
    public void onDestroy() {
        // 服务不再被使用，正在被销毁
    }
}

<Android SDK>/platforms/<任意android api 版本>/ data/ broadcast_actions.txt

    
<receiver android:name=".MyBroadcastReceiver"  android:exported="true">
        <intent-filter>
            <action android:name="android.intent.action.BOOT_COMPLETED"/>
            <action android:name="android.intent.action.INPUT_METHOD_CHANGED" />
        </intent-filter>
    </receiver>

    
public class MyBroadcastReceiver extends BroadcastReceiver {
            private static final String TAG = "MyBroadcastReceiver";
            @Override
            public void onReceive(Context context, Intent intent) {
                StringBuilder sb = new StringBuilder();
                sb.append("Action: " + intent.getAction() + "\n");
                sb.append("URI: " + intent.toUri(Intent.URI_INTENT_SCHEME).toString() + "\n");
                String log = sb.toString();
                Log.d(TAG, log);
                Toast.makeText(context, log, Toast.LENGTH_LONG).show();
            }
        }

BroadcastReceiver br = new MyBroadcastReceiver();

IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
filter.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED);
this.registerReceiver(br, filter);

    
public class MyBroadcastReceiver extends BroadcastReceiver {
        private static final String TAG = "MyBroadcastReceiver";
        @Override
        public void onReceive(Context context, Intent intent) {
            final PendingResult pendingResult = goAsync();
            Task asyncTask = new Task(pendingResult, intent);
            asyncTask.execute();
        }
        private static class Task extends AsyncTask<String, Integer, String> {
            private final PendingResult pendingResult;
            private final Intent intent;
            private Task(PendingResult pendingResult, Intent intent) {
                this.pendingResult = pendingResult;
                this.intent = intent;
            }
            @Override
            protected String doInBackground(String... strings) {
                StringBuilder sb = new StringBuilder();
                sb.append("Action: " + intent.getAction() + "\n");
                sb.append("URI: " + intent.toUri(Intent.URI_INTENT_SCHEME).toString() + "\n");
                String log = sb.toString();
                Log.d(TAG, log);
                return log;
            }
            @Override
            protected void onPostExecute(String s) {
                super.onPostExecute(s);
                // Must call finish() so the BroadcastReceiver can be recycled.
                pendingResult.finish();
            }
        }
    }

    
Intent intent = new Intent();
    intent.setAction("com.example.broadcast.MY_NOTIFICATION");
    intent.putExtra("data","Notice me senpai!");
    sendBroadcast(intent);

    
sendBroadcast(new Intent("com.example.NOTIFY"),
                  Manifest.permission.SEND_SMS);

<uses-permission android:name="android.permission.SEND_SMS"/>

<receiver android:name=".MyBroadcastReceiver"
              android:permission="android.permission.SEND_SMS">
        <intent-filter>
            <action android:name="android.intent.action.AIRPLANE_MODE"/>
        </intent-filter>
    </receiver>

IntentFilter filter = new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED);
    registerReceiver(receiver, filter, Manifest.permission.SEND_SMS, null );

<uses-permission android:name="android.permission.SEND_SMS"/>

// 查询用户字典并返回结果
cursor = getContentResolver().query(
    UserDictionary.Words.CONTENT_URI,   // words表的内容URI
    projection,                        // 为每行返回的列
    selectionClause,                   // 选择标准
    selectionArgs,                     // 选择标准
    sortOrder);                        // 返回行的排序顺序

content://user_dictionary/words

Uri singleUri = ContentUris.withAppendedId(UserDictionary.Words.CONTENT_URI,4);

<uses-permission android:name="android.permission.READ_USER_DICTIONARY" />

// 一个“projection”定义了将为每一行返回的列。
String[] mProjection =
{
    UserDictionary.Words._ID,    // 用于_ID列名的Contract类常量
    UserDictionary.Words.WORD,   // 用于WORD列名的Contract类常量
    UserDictionary.Words.LOCALE  // LOCALE列名的Contract类常量
};
// 定义一个包含选择子句的字符串
String selectionClause = null;
// 初始化一个数组以包含选择参数
String[] selectionArgs = {""};

/*
 * 这里定义了一个包含一个元素的字符串数组，用于存储选择参数的值。
 */
String[] selectionArgs = {""};
// 从UI中获取一个单词
searchString = searchWord.getText().toString();
// 记得在这里插入代码来检查无效或恶意输入。
// 如果单词是空字符串，获取所有内容
if (TextUtils.isEmpty(searchString)) {
    // 将选择子句设置为null将返回所有单词
    selectionClause = null;
    selectionArgs[0] = "";
} else {
    // 构造一个选择子句，匹配用户输入的单词。
    selectionClause = UserDictionary.Words.WORD + " = ?";
    // 将用户输入的字符串移动到选择参数中。
    selectionArgs[0] = searchString;
}
// 对表进行查询，并返回一个Cursor对象
mCursor = getContentResolver().query(
    UserDictionary.Words.CONTENT_URI,  // 单词表的内容URI
    projection,                       // 每行返回的列
    selectionClause,                  // 要么为null，要么为用户输入的单词
    selectionArgs,                    // 要么为空，要么为用户输入的字符串
    sortOrder);                       // 返回行的排序顺序
// 一些内容提供者在发生错误时返回null，其他的则抛出异常
if (null == mCursor) {
    /*
     * 在这里插入代码来处理错误。确保不要使用cursor！你可以调用android.util.Log.e()来记录这个错误。
     *
     */
// 如果Cursor为空，表内容提供者没有找到匹配的结果
} else if (mCursor.getCount() < 1) {
    /*
     * 在这里插入代码来通知用户搜索无果。这不一定是一个错误。你可以提供给用户插入新行或重新输入搜索词的选项。
     */
} else {
    // 在这里插入代码来处理结果
}

SELECT _ID, word, locale FROM words WHERE word = <userinput> ORDER BY word ASC;

// 通过将用户的输入连接到列名来构造选择子句。
String selectionClause = "var = " + userInput;

// 通过使用可替换的参数构建一个选择子句。
String selectionClause =  "var = ?";

// 可以定义一个数组来存储选择参数。
String[] selectionArgs = {""};

// 将选择参数设置为用户的输入。
selectionArgs[0] = userInput;

// 定义要从 Cursor 中检索并加载到输出行的列的列表
String[] wordListColumns =
{
    UserDictionary.Words.WORD,   // Contract类常量，包含单词列的名称
    UserDictionary.Words.LOCALE  // Contract类常量，包含区域设置列的名称
};
// 定义将为每行接收 Cursor 列的视图ID列表
int[] wordListItems = { R.id.dictWord, R.id.locale};
// 创建一个新的 SimpleCursorAdapter
cursorAdapter = new SimpleCursorAdapter(
    getApplicationContext(),               // 应用程序的 Context 对象
    R.layout.wordlistrow,                  // 用于 ListView 中的一行的 XML 布局
    mCursor,                               // 查询的结果
    wordListColumns,                      // Cursor 中的列名称的字符串数组
    wordListItems,                        // 行布局中的视图 ID 的整数数组
    0);                                    // 标志（通常不需要）
// 为 ListView 设置适配器
wordList.setAdapter(cursorAdapter);

// 确定名为 "word" 的列的索引位置
int index = mCursor.getColumnIndex(UserDictionary.Words.WORD);
/*
 * 只有当 Cursor 有效时才执行。如果发生内部错误，用户字典内容提供者将返回 null。其内容提供者可能会抛出异常，而不是返回 null。
   */
if (mCursor != null) {
    /*
     * 移动到 Cursor 中的下一行。在 Cursor 的第一次移动之前，"行指针" 为 -1，如果您尝试在该位置检索数据，将会引发异常。
     */
    while (mCursor.moveToNext()) {
        // 从列中获取值
        newWord = mCursor.getString(index);
            // 在此处插入处理检索到的单词的代码。
            ...
            // 循环结束
    }
} else {
    // 在此处插入代码，如果 Cursor 为 null 或内容提供者抛出异常，则报告错误。
}

// 定义一个新的 Uri 对象，用于接收插入操作的结果
Uri newUri;
...
// 定义一个对象来存储要插入的新值
ContentValues newValues = new ContentValues();
/*
 * 设置每一列的值，并插入单词。"put" 方法的参数是 "列名" 和 "值"
   */
   newValues.put(UserDictionary.Words.APP_ID, "example.user");
   newValues.put(UserDictionary.Words.LOCALE, "en_US");
   newValues.put(UserDictionary.Words.WORD, "insert");
   newValues.put(UserDictionary.Words.FREQUENCY, "100");
// 调用 ContentResolver 的 insert 方法将新值插入到用户字典内容提供者中，并返回新行的内容 URI
newUri = getContentResolver().insert(
    UserDictionary.Words.CONTENT_URI,   // 用户字典内容 URI
    newValues                          // 要插入的值
);

content://user_dictionary/words/<id_value>

long id = ContentUris.parseId(newUri);

// 定义一个对象来包含更新的值
ContentValues updateValues = new ContentValues();
// 定义选择条件来更新需要更新的行
String selectionClause = UserDictionary.Words.LOCALE + " LIKE ?";
String[] selectionArgs = {"en_%"};
// 定义一个变量来保存更新的行数
int rowsUpdated = 0;
...
/*
 * 设置更新的值并更新选定的单词。
   */
   updateValues.putNull(UserDictionary.Words.LOCALE);
rowsUpdated = getContentResolver().update(
    UserDictionary.Words.CONTENT_URI,   // 用户词典内容的URI
    updateValues,                      // 需要更新的列
    selectionClause,                   // 选择的列
    selectionArgs                      // 与之比较的值
);

// 定义选择条件来删除需要删除的行
String selectionClause = UserDictionary.Words.APP_ID + " LIKE ?";
String[] selectionArgs = {"user"};
// 定义一个变量来保存已删除的行数
int rowsDeleted = 0;
...
// 删除符合选择条件的单词
rowsDeleted = getContentResolver().delete(
    UserDictionary.Words.CONTENT_URI,   // 用户词典内容的URI
    selectionClause,                   // 选择的列
    selectionArgs                      // 与之比较的值
);

String[] projection =
{
    UserDictionary.Words._ID,
    UserDictionary.Words.WORD,
    UserDictionary.Words.LOCALE
};

type/subtype

vnd.android.cursor.dir

vnd.android.cursor.item

vnd.android.cursor.item/phone_v2

content://com.example.trains/Line1

vnd.android.cursor.dir/vnd.example.line1

content://com.example.trains/Line2/5

vnd.android.cursor.item/vnd.example.line2

三
模拟点开APP就是广告的APP

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="end">
        <Button
            android:id="@+id/closeButton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/button_text_one"
            android:layout_alignParentEnd="true"
            android:layout_alignParentTop="true"
            android:layout_margin="8dp" />
    </RelativeLayout>
    <TextView
        android:id="@+id/closeText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/text_one"
        android:textSize="18sp"
        android:gravity="center" />
</LinearLayout>

package com.example.fourmodule;
import androidx.appcompat.app.AppCompatActivity;
import android.annotation.SuppressLint;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import java.lang.Runnable;
public class MainActivity extends AppCompatActivity {
    private Handler handler; // 用于处理延迟任务的Handler对象
    private Runnable closeRunnable; // 延迟任务的Runnable对象
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
            // 初始化Handler和Runnable
        handler = new Handler();
        closeRunnable = new Runnable() {
            @Override
            public void run() {
                closeActivity();
            }
        };
            // 启动计时器，延迟五秒后关闭界面
        handler.postDelayed(closeRunnable, 5000);
            // 关闭按钮点击事件
        Button closeButton = findViewById(R.id.closeButton);
        closeButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 取消计时器并关闭界面
                handler.removeCallbacks(closeRunnable);
                closeActivity();
            }
        });
            // 根布局点击事件
        @SuppressLint({"MissingInflatedId", "LocalSuppress"}) View rootView = findViewById(R.id.closeText);
        rootView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 启动服务
                startService(new Intent(MainActivity.this, MyService.class));
            }
        });
    }
        private void closeActivity() {
        // 关闭界面
        finish();
        // 进入新的界面
        startActivity(new Intent(MainActivity.this, NewActivity.class));
    }
}

<activity
    android:name=".MainActivity"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

package com.example.fourmodule;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.widget.Toast;
import androidx.annotation.Nullable;
public class MyService extends Service {
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 在服务启动时执行的逻辑
        Toast.makeText(this, "服务已启动", Toast.LENGTH_SHORT).show();
            return START_STICKY;
    }
        @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
        @Override
    public void onDestroy() {
        super.onDestroy();
        Toast.makeText(this, "服务已关闭", Toast.LENGTH_SHORT).show();
    }
}

<service android:name=".MyService" />

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/root_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@android:color/white"
    android:clickable="true"
    android:focusable="true"
    android:focusableInTouchMode="true"
    android:gravity="center"
    tools:context=".NewActivity">
    <!-- 其他界面元素 -->
    <TextView
        android:id="@+id/Text_Show"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:text="@string/text_two">
    </TextView>
    <Button
        android:id="@+id/Service_Stop"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/Text_Show"
        android:layout_centerHorizontal="true"
        android:gravity="center"
        android:text="@string/stop_button">
    </Button>
    </RelativeLayout>

package com.example.fourmodule;
import android.annotation.SuppressLint;
import android.content.Intent;
import android.content.IntentFilter;
import android.database.Cursor;
import android.os.Bundle;
import android.provider.UserDictionary;
import android.view.View;
import android.widget.Button;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
public class NewActivity extends AppCompatActivity {
    private BroadcastReceiver myReceiver; // 广播接收器对象
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_new); // 设置布局文件
        Button stopButton = findViewById(R.id.Service_Stop); // 获取按钮对象
        stopButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(NewActivity.this, MyService.class); // 创建意图对象，指定要停止的服务
                stopService(intent); // 停止服务
            }
        });
        // 创建意图过滤器对象，并设置要监听的广播频道为飞行模式的开启与关闭
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED);
        myReceiver = new MyReceiver(); // 创建广播接收器对象
        // 注册广播接收器，将其与意图过滤器关联起来
        this.registerReceiver(myReceiver, intentFilter);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 停止接收广播，避免内存泄漏
        if (myReceiver != null) {
            this.unregisterReceiver(myReceiver);
        }
    }
}

<activity android:name=".NewActivity" />

package com.example.fourmodule;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
public class MyReceiver extends BroadcastReceiver {
    // BroadcastReceiver的回调方法，当接收到广播时，系统会回调该方法
    @Override
    public void onReceive(Context context, Intent intent) {
        // 获取广播的Action
        String action = intent.getAction();
        // 判断广播是否为飞行模式改变的广播
        if (action != null && action.equals(Intent.ACTION_AIRPLANE_MODE_CHANGED)) {
            // 获取飞行模式状态
            boolean isAirplaneModeOn = intent.getBooleanExtra("state", false);
            // 创建一个新的Intent对象，用于启动ReceiverActivity
            Intent updateIntent = new Intent(context, ReceiverActivity.class);
            // 将飞行模式状态添加到Intent中
            updateIntent.putExtra("isAirplaneModeOn", isAirplaneModeOn);
            // 启动ReceiverActivity
            context.startActivity(updateIntent);
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="end">
        <Button
            android:id="@+id/receiverButton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/button_text_one"
            android:layout_alignParentEnd="true"
            android:layout_alignParentTop="true"
            android:layout_margin="8dp" />
    </RelativeLayout>
    <TextView
        android:id="@+id/Text_Changed"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/changed_no"
        android:textSize="18sp"
        android:gravity="center" />
</LinearLayout>

package com.example.fourmodule;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
public class ReceiverActivity extends AppCompatActivity {
    private Handler handler;
    private Runnable closeRunnable;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_receiver);
        TextView textView = findViewById(R.id.Text_Changed);
        Intent intent = getIntent();
        if (intent != null && intent.hasExtra("isAirplaneModeOn")) {
            boolean isAirplaneModeOn = intent.getBooleanExtra("isAirplaneModeOn", false);
            if (isAirplaneModeOn) {
                // 修改文本样式为飞行模式开启时的样式
                textView.setText(R.string.changed_yes);
            } else {
                // 修改文本样式为飞行模式关闭时的样式
                textView.setText(R.string.changed_no);
            }
        }
        // 初始化Handler和Runnable
        handler = new Handler();
        closeRunnable = new Runnable() {
            @Override
            public void run() {
                closeActivity();
            }
        };
        // 启动计时器，延迟五秒后关闭界面
        handler.postDelayed(closeRunnable, 5000);
        // 关闭按钮点击事件
        Button closeButton = findViewById(R.id.receiverButton);
        closeButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 取消计时器并关闭界面
                handler.removeCallbacks(closeRunnable);
                closeActivity();
            }
        });
    }
    private void closeActivity() {
        // 关闭界面
        finish();
        // 进入新的界面
        startActivity(new Intent(ReceiverActivity.this, NewActivity.class));
    }
}

<activity android:name=".ReceiverActivity" />

<resources>
    <string name="app_name">FourModule</string>
    <string name="button_text_one">关闭</string>
    <string name="text_one">走过路过不要错过，过了这个村就没这家店了！</string>
    <string name="text_two">这个是正文！</string>
    <string name="changed_yes">飞行模式现处于打开状态</string>
    <string name="changed_no">飞行模式现处于关闭状态</string>
    <string name="stop_button">关闭服务</string>
    <string name="content_text_one">检索用户字典的数据</string>
</resources>

package com.example.fourmodule;
class MainActivity$1 implements Runnable {
    final MainActivity this$0;
    MainActivity$1(MainActivity mainActivity) {
        this.this$0 = mainActivity;
    }
        @Override
    public void run() {
        MainActivity.access$000(this.this$0);
    }
}

closeRunnable = new Runnable() {
    @Override
    public void run() {
        closeActivity();
    }
};

//
// Decompiled by Jadx - 479ms
//
package com.example.fourmodule;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.widget.Button;
import androidx.appcompat.app.AppCompatActivity;
public class MainActivity extends AppCompatActivity {
    private Runnable closeRunnable;
    private Handler handler;
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        setContentView(R.layout.activity_main);
        this.handler = new Handler();
        Runnable runnable = new MainActivity$1(this);
        this.closeRunnable = runnable;
        this.handler.postDelayed(runnable, 5000L);
        ((Button) findViewById(R.id.closeButton)).setOnClickListener(new MainActivity$2(this));
        findViewById(R.id.closeText).setOnClickListener(new MainActivity$3(this));
    }
        /* JADX WARN: Multi-variable type inference failed */
    public void closeActivity() {
        finish();
        startActivity(new Intent((Context) this, (Class<?>) NewActivity.class));
    }
}

new-instance v0, Landroid/content/Intent;
const-class v1, Lcom/example/fourmodule/ReceiverActivity;
invoke-direct {v0, p1, v1}, Landroid/content/Intent;-><init>(Landroid/content/Context;Ljava/lang/Class;)V
const-string v1, "isAirplaneModeOn"
.line 16
invoke-virtual {v0, v1, p2}, Landroid/content/Intent;->putExtra(Ljava/lang/String;Z)Landroid/content/Intent;
.line 17
invoke-virtual {p1, v0}, Landroid/content/Context;->startActivity(Landroid/content/Intent;)V
:cond_24
return-void

new-instance v0, Landroid/content/Intent;
const-class v1, Lcom/example/fourmodule/ReceiverActivity;
invoke-direct {v0, p1, v1}, Landroid/content/Intent;-><init>(Landroid/content/Context;Ljava/lang/Class;)V

# 往期推荐

1、区块链智能合约逆向-合约创建-调用执行流程分析

2、在Windows平台使用VS2022的MSVC编译LLVM16

3、神挡杀神——揭开世界第一手游保护nProtect的神秘面纱

4、为什么在ASLR机制下DLL文件在不同进程中加载的基址相同

5、2022QWB final RDP

6、华为杯研究生国赛 adv_lua