菜鸟教程 – 学的不仅是技术，更是梦想！

技术网站，更是交流网站

Android

Service初涉

likuolei

感谢你提到 Service 初涉！Service 是 Android 的四大核心组件之一，用于在后台执行长时间运行的任务或提供功能，而不直接提供用户界面。作为初学者，“初涉” Service 意味着需要掌握其基本概念、类型、生命周期以及与 Activity 等组件的交互。本回答将为初学者提供简洁易懂的 Service 入门指南，结合你之前提到的组件（如 Activity、AlertDialog、PopupWindow、Menu、ViewPager2、DrawerLayout、TextWatcher、Configuration、AsyncTask、Gestures）以及相关话题（如 Handler、OnTouchListener、onTouchEvent、多点触碰），通过一个综合示例展示 Service 的基本使用，重点与 Activity 交互，涵盖代码、生命周期管理、优化建议和常见问题处理。如果你的需求涉及特定功能（如复杂后台任务、与 Activity 的通信）或有具体问题，请提供更多细节，我可以进一步定制答案。

1. Service 核心概念

定义：
Service 是一个在后台运行的组件，适合执行无需用户界面的任务（如播放音乐、下载文件、定时任务）。它运行在主线程，耗时操作需使用子线程（如 AsyncTask 或 Executor）。

类型：

  1. Started Service（启动服务）：
  • 由 startService() 启动，执行特定任务，完成后可自行停止。
  • 用途：后台下载、定时检查。
  1. Bound Service（绑定服务）：
  • 通过 bindService() 与客户端（通常是 Activity）绑定，提供服务接口。
  • 用途：跨进程通信、实时数据提供。
  1. Foreground Service（前台服务）：
  • 显示通知，适合用户感知的任务（如音乐播放）。
  • 需在 Android 8.0+ 调用 startForeground()。
  1. IntentService（已弃用）：
  • 基于队列处理 Intent，适合简单任务（推荐用 WorkManager 替代）。

生命周期：

  1. Started Service：
  • onCreate()：服务创建时调用，初始化资源。
  • onStartCommand(Intent, int, int)：每次 startService() 调用，处理 Intent。
  • onDestroy()：服务销毁时调用，清理资源。
  1. Bound Service（额外方法）：
  • onBind(Intent)：客户端绑定时调用，返回 IBinder。
  • onUnbind(Intent)：客户端解绑时调用。
  • onRebind(Intent)：重新绑定时调用。

初学者要点：

  • Service 运行在主线程，耗时任务需异步处理。
  • 前台服务需通知，遵守 Android 权限要求。
  • 与 Activity 通信通常通过 Intent、广播、绑定或 Handler。
  • 现代替代方案：WorkManager（定时/后台任务）、ForegroundService（持久任务）。

局限性：

  • 无 UI，需通过通知或其他方式反馈用户。
  • 生命周期管理复杂，需防止内存泄漏。
  • Android 8.0+ 对后台服务限制严格，推荐前台服务或 WorkManager。

2. Service 生命周期

Started Service：

onCreate() → onStartCommand() → onDestroy()

Bound Service：

onCreate() → onBind() → onUnbind() → onRebind() → onDestroy()

初学者注意：

  • onCreate 初始化一次，onStartCommand 可多次调用。
  • 使用 START_STICKY、START_NOT_STICKY 等标志控制服务重启行为。
  • 清理资源在 onDestroy：
  @Override
  public void onDestroy() {
      super.onDestroy();
      // 清理资源
  }

3. 综合示例：Service 与 Activity 交互

以下是一个简单综合示例，展示 Started Service 和 Bound Service 的使用，结合 Activity（包含 DrawerLayout、ViewPager2、TextWatcher）实现以下功能：

  • Service：定时计数（模拟后台任务），通过 LocalBroadcastManager 向 Activity 发送结果。
  • Activity：显示计数结果，控制服务启动/停止，响应输入和屏幕旋转。
  • 手势：单击 ImageView 启动/停止服务。
  • 异步任务：服务中使用 Handler 模拟定时任务。
  • 状态保存：保存输入和计数结果。

3.1 布局文件（res/layout/activity_main.xml）

包含 Toolbar、EditText、ImageView、TextView、ViewPager2 和 DrawerLayout。

3.2 菜单资源（res/menu/nav_menu.xml）

侧滑菜单。

3.3 字符串资源（res/values/strings.xml）

支持多语言。

Service 初涉 Open navigation drawer Close navigation drawer Start Service Stop Service Bind Service Enter service data

中文资源（res/values-zh/strings.xml）：
Service 初涉 打开导航抽屉 关闭导航抽屉 启动服务 停止服务 绑定服务 输入服务数据

3.4 Fragment 页面（PageFragment.java）

用于 ViewPager2。


package com.example.myapp;

import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.fragment.app.Fragment;

public class PageFragment extends Fragment {
private static final String ARG_PAGE = “page”;
private static final String ARG_COUNT = “count”;
private TextView textView;

public static PageFragment newInstance(int page, int count) {
    PageFragment fragment = new PageFragment();
    Bundle args = new Bundle();
    args.putInt(ARG_PAGE, page);
    args.putInt(ARG_COUNT, count);
    fragment.setArguments(args);
    return fragment;
}

@Override
public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(android.R.layout.simple_list_item_1, container, false);
    textView = view.findViewById(android.R.id.text1);
    updateContent();
    return view;
}

public void updateCount(int count) {
    if (getArguments() != null) {
        getArguments().putInt(ARG_COUNT, count);
        updateContent();
    }
}

private void updateContent() {
    int page = getArguments() != null ? getArguments().getInt(ARG_PAGE) : 0;
    int count = getArguments() != null ? getArguments().getInt(ARG_COUNT, 0) : 0;
    textView.setText("页面 " + (page + 1) + "\n计数: " + count);
}

}

3.5 Service 代码（CounterService.java）

实现 Started Service 和 Bound Service，定时计数并发送结果。


package com.example.myapp;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import androidx.core.app.NotificationCompat;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;

public class CounterService extends Service {
private static final String CHANNEL_ID = “CounterServiceChannel”;
private static final int NOTIFICATION_ID = 1;
private final IBinder binder = new CounterBinder();
private Handler handler;
private int counter = 0;
private boolean isRunning = false;
private String inputData = “”;
private final Runnable counterRunnable = new Runnable() {
@Override
public void run() {
if (isRunning) {
counter++;
sendBroadcastUpdate();
handler.postDelayed(this, 1000);
}
}
};

public class CounterBinder extends Binder {
    CounterService getService() {
        return CounterService.this;
    }
}

@Override
public void onCreate() {
    super.onCreate();
    handler = new Handler(Looper.getMainLooper());
    createNotificationChannel();
    startForeground(NOTIFICATION_ID, createNotification("服务启动"));
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    if (intent != null) {
        inputData = intent.getStringExtra("input") != null ? intent.getStringExtra("input") : "默认任务";
    }
    if (!isRunning) {
        isRunning = true;
        counter = 0;
        handler.post(counterRunnable);
    }
    return START_STICKY;
}

@Override
public IBinder onBind(Intent intent) {
    return binder;
}

@Override
public boolean onUnbind(Intent intent) {
    return true; // 允许重新绑定
}

@Override
public void onDestroy() {
    super.onDestroy();
    isRunning = false;
    handler.removeCallbacks(counterRunnable);
    stopForeground(true);
}

public int getCounter() {
    return counter;
}

public String getInputData() {
    return inputData;
}

private void sendBroadcastUpdate() {
    Intent intent = new Intent("com.example.myapp.COUNTER_UPDATE");
    intent.putExtra("counter", counter);
    intent.putExtra("input", inputData);
    LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
}

private void createNotificationChannel() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        NotificationChannel channel = new NotificationChannel(
                CHANNEL_ID,
                "Counter Service",
                NotificationManager.IMPORTANCE_LOW
        );
        NotificationManager manager = getSystemService(NotificationManager.class);
        manager.createNotificationChannel(channel);
    }
}

private Notification createNotification(String content) {
    Intent intent = new Intent(this, MainActivity.class);
    PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_IMMUTABLE);
    return new NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("计数服务")
            .setContentText(content + ": " + counter)
            .setSmallIcon(android.R.drawable.ic_notification_overlay)
            .setContentIntent(pendingIntent)
            .setOngoing(true)
            .build();
}

}

3.6 AndroidManifest.xml

声明 Service 和权限。

3.7 Activity 代码（MainActivity.java）

控制 Service 并显示结果。


package com.example.myapp;

import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.content.res.Configuration;
import android.os.Bundle;
import android.os.IBinder;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.MotionEvent;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.appcompat.app.ActionBarDrawerToggle;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.core.view.GestureDetectorCompat;
import androidx.core.view.GravityCompat;
import androidx.drawerlayout.widget.DrawerLayout;
import androidx.fragment.app.Fragment;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;
import androidx.viewpager2.adapter.FragmentStateAdapter;
import androidx.viewpager2.widget.ViewPager2;
import com.google.android.material.navigation.NavigationView;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

public class MainActivity extends AppCompatActivity {
private DrawerLayout drawerLayout;
private ViewPager2 viewPager;
private EditText inputEditText;
private TextView resultText;
private ImageView controlImage;
private TextWatcher textWatcher;
private ViewPagerAdapter viewPagerAdapter;
private GestureDetectorCompat gestureDetector;
private BroadcastReceiver counterReceiver;
private CounterService counterService;
private boolean isBound = false;
private boolean isServiceRunning = false;
private int counter = 0;
private final ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
CounterService.CounterBinder binder = (CounterService.CounterBinder) service;
counterService = binder.getService();
isBound = true;
updateUIFromService();
}

    @Override
    public void onServiceDisconnected(ComponentName name) {
        isBound = false;
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Toast.makeText(this, "onCreate", Toast.LENGTH_SHORT).show();

    // 初始化 Toolbar
    Toolbar toolbar = findViewById(R.id.toolbar);
    setSupportActionBar(toolbar);

    // 初始化 DrawerLayout
    drawerLayout = findViewById(R.id.drawerLayout);
    ActionBarDrawerToggle toggle = new ActionBarDrawerToggle(
            this, drawerLayout, toolbar,
            R.string.navigation_drawer_open, R.string.navigation_drawer_close);
    drawerLayout.addDrawerListener(toggle);
    toggle.syncState();

    // 侧滑菜单
    NavigationView navigationView = findViewById(R.id.navigationView);
    navigationView.setNavigationItemSelectedListener(item -> {
        int itemId = item.getItemId();
        if (itemId == R.id.nav_start) {
            startCounterService();
        } else if (itemId == R.id.nav_stop) {
            stopCounterService();
        } else if (itemId == R.id.nav_bind) {
            bindCounterService();
        }
        drawerLayout.closeDrawers();
        return true;
    });

    // 初始化 ViewPager2
    viewPager = findViewById(R.id.viewPager);
    viewPagerAdapter = new ViewPagerAdapter(this);
    viewPager.setAdapter(viewPagerAdapter);

    // 初始化 UI 组件
    inputEditText = findViewById(R.id.inputEditText);
    resultText = findViewById(R.id.resultText);
    controlImage = findViewById(R.id.controlImage);

    // 初始化 TextWatcher
    textWatcher = new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {}

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {}

        @Override
        public void afterTextChanged(Editable s) {
            String input = s.toString();
            if (input.equalsIgnoreCase("english")) {
                setLocale(new Locale("en"));
            } else if (input.equalsIgnoreCase("chinese")) {
                setLocale(new Locale("zh"));
            } else if (input.equalsIgnoreCase("reset")) {
                counter = 0;
                resultText.setText("计数: 0");
                viewPagerAdapter.updateCount(0);
                stopCounterService();
                controlImage.setImageResource(android.R.drawable.ic_media_play);
            }
        }
    };
    inputEditText.addTextChangedListener(textWatcher);

    // 初始化手势
    gestureDetector = new GestureDetectorCompat(this, new GestureDetector.SimpleOnGestureListener() {
        @Override
        public boolean onSingleTapUp(MotionEvent e) {
            if (isServiceRunning) {
                stopCounterService();
            } else {
                startCounterService();
            }
            return true;
        }
    });
    controlImage.setOnTouchListener((v, event) -> {
        viewPager.requestDisallowInterceptTouchEvent(true);
        gestureDetector.onTouchEvent(event);
        return true;
    });

    // 初始化广播接收器
    counterReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            counter = intent.getIntExtra("counter", 0);
            String input = intent.getStringExtra("input");
            resultText.setText("计数: " + counter + "\n输入: " + input);
            viewPagerAdapter.updateCount(counter);
        }
    };
    LocalBroadcastManager.getInstance(this).registerReceiver(
            counterReceiver, new IntentFilter("com.example.myapp.COUNTER_UPDATE"));

    // 恢复状态
    if (savedInstanceState != null) {
        counter = savedInstanceState.getInt("counter", 0);
        String input = savedInstanceState.getString("input", "");
        inputEditText.setText(input);
        resultText.setText("计数: " + counter);
        viewPagerAdapter.updateCount(counter);
        isServiceRunning = savedInstanceState.getBoolean("isServiceRunning", false);
        controlImage.setImageResource(isServiceRunning ?
                android.R.drawable.ic_media_stop : android.R.drawable.ic_media_play);
    }
}

private void startCounterService() {
    Intent intent = new Intent(this, CounterService.class);
    intent.putExtra("input", inputEditText.getText().toString());
    startService(intent);
    isServiceRunning = true;
    controlImage.setImageResource(android.R.drawable.ic_media_stop);
    Toast.makeText(this, "服务启动", Toast.LENGTH_SHORT).show();
}

private void stopCounterService() {
    Intent intent = new Intent(this, CounterService.class);
    stopService(intent);
    isServiceRunning = false;
    controlImage.setImageResource(android.R.drawable.ic_media_play);
    Toast.makeText(this, "服务停止", Toast.LENGTH_SHORT).show();
}

private void bindCounterService() {
    Intent intent = new Intent(this, CounterService.class);
    bindService(intent, connection, Context.BIND_AUTO_CREATE);
    Toast.makeText(this, "绑定服务", Toast.LENGTH_SHORT).show();
}

private void updateUIFromService() {
    if (isBound && counterService != null) {
        counter = counterService.getCounter();
        String input = counterService.getInputData();
        resultText.setText("计数: " + counter + "\n输入: " + input);
        viewPagerAdapter.updateCount(counter);
    }
}

@Override
protected void onStart() {
    super.onStart();
    Toast.makeText(this, "onStart", Toast.LENGTH_SHORT).show();
}

@Override
protected void onResume() {
    super.onResume();
    Toast.makeText(this, "onResume", Toast.LENGTH_SHORT).show();
}

@Override
protected void onPause() {
    super.onPause();
    Toast.makeText(this, "onPause", Toast.LENGTH_SHORT).show();
}

@Override
protected void onStop() {
    super.onStop();
    Toast.makeText(this, "onStop", Toast.LENGTH_SHORT).show();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    Toast.makeText(this, "onDestroy", Toast.LENGTH_SHORT).show();
    inputEditText.removeTextChangedListener(textWatcher);
    LocalBroadcastManager.getInstance(this).unregisterReceiver(counterReceiver);
    if (isBound) {
        unbindService(connection);
        isBound = false;
    }
}

@Override
protected void onRestart() {
    super.onRestart();
    Toast.makeText(this, "onRestart", Toast.LENGTH_SHORT).show();
}

@Override
public void onConfigurationChanged(@NonNull Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    resultText.setText("计数: " + counter + "\n配置: " +
            (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT ? "竖屏" : "横屏"));
    viewPagerAdapter.updateCount(counter);
    Toast.makeText(this, "配置变化", Toast.LENGTH_SHORT).show();
}

@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt("counter", counter);
    outState.putString("input", inputEditText.getText().toString());
    outState.putBoolean("isServiceRunning", isServiceRunning);
}

@Override
public void onBackPressed() {
    if (drawerLayout.isDrawerOpen(GravityCompat.START)) {
        drawerLayout.closeDrawer(GravityCompat.START);
    } else {
        super.onBackPressed();
    }
}

private void setLocale(Locale locale) {
    Locale.setDefault(locale);
    Configuration config = new Configuration();
    config.setLocale(locale);
    getResources().updateConfiguration(config, getResources().getDisplayMetrics());
    recreate();
}

private static class ViewPagerAdapter extends FragmentStateAdapter {
    private final List<PageFragment> fragments = new ArrayList<>();
    private int counter = 0;

    public ViewPagerAdapter(AppCompatActivity activity) {
        super(activity);
        for (int i = 0; i < 2; i++) {
            fragments.add(PageFragment.newInstance(i, counter));
        }
    }

    public void updateCount(int count) {
        this.counter = count;
        for (PageFragment fragment : fragments) {
            fragment.updateCount(count);
        }
        notifyDataSetChanged();
    }

    @NonNull
    @Override
    public Fragment createFragment(int position) {
        return fragments.get(position);
    }

    @Override
    public int getItemCount() {
        return 2;
    }
}

}

3.8 运行效果

  • 生命周期：Activity 和 Service 的生命周期通过 Toast 展示。
  • 界面：包含 Toolbar、EditText（输入监听）、ImageView（控制服务）、TextView（显示计数）、ViewPager2（2 个页面）、DrawerLayout（菜单）。
  • Service 功能：
  • 启动：侧滑菜单“Start”或单击 ImageView，启动 CounterService，每秒计数并通过广播更新 UI。
  • 停止：侧滑菜单“Stop”或单击 ImageView，停止服务。
  • 绑定：侧滑菜单“Bind”，绑定服务并获取计数。
  • 手势：单击 ImageView 切换服务启停状态，更新图标（播放/停止）。
  • TextWatcher：
  • 输入“english”/“chinese”切换语言。
  • 输入“reset”重置计数和服务。
  • 广播：Service 通过 LocalBroadcastManager 发送计数更新。
  • 配置变化：屏幕旋转时保留计数和输入。
  • 状态保存：保存计数、输入和服务状态。

说明：

  • Service：作为前台服务运行，显示通知，定时计数。
  • 通信：使用 LocalBroadcastManager 安全高效。
  • 绑定：通过 ServiceConnection 获取服务数据。
  • 手势：简单单击控制服务。
  • 优化：使用 START_STICKY 确保服务重启，PendingIntent 跳转 Activity。

4. 初学者常见问题及解决

  1. Service 不运行：
  • 问题：未正确声明或缺少权限。
  • 解决：在 AndroidManifest.xml 声明 Service 和 FOREGROUND_SERVICE 权限：
    xml <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
  1. UI 无更新：
  • 问题：Service 未通知 Activity。
  • 解决：使用广播或绑定：
    java LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
  1. 内存泄漏：
  • 问题：未解绑服务或未注销广播。
  • 解决：在 onDestroy 清理：
    java @Override protected void onDestroy() { LocalBroadcastManager.getInstance(this).unregisterReceiver(counterReceiver); if (isBound) { unbindService(connection); } super.onDestroy(); }
  1. 服务被杀死：
  • 问题：系统杀死服务后未恢复。
  • 解决：返回 START_STICKY：
    java @Override public int onStartCommand(Intent intent, int flags, int startId) { return START_STICKY; }
  1. 通知不显示：
  • 问题：Android 8.0+ 未创建通知渠道。
  • 解决：创建渠道并调用 startForeground：
    java startForeground(NOTIFICATION_ID, createNotification("服务启动"));

5. 初学者进阶功能

  1. Bound Service 增强：
  • 提供更多方法：
    java public class CounterBinder extends Binder { CounterService getService() { return CounterService.this; } } public void resetCounter() { counter = 0; sendBroadcastUpdate(); }
  1. 前台服务通知更新：
  • 动态更新通知：
    java NotificationManager manager = getSystemService(NotificationManager.class); manager.notify(NOTIFICATION_ID, createNotification("计数: " + counter));
  1. 结合 Handler：
  • 延迟启动服务：
    java Handler handler = new Handler(Looper.getMainLooper()); handler.postDelayed(() -> startCounterService(), 1000);
  1. 与 Activity 交互：
  • 通过 Intent 传递复杂数据：
    java Intent intent = new Intent(this, CounterService.class); intent.putExtra("data", new Bundle()); startService(intent);

6. 结合之前组件

  • Activity：控制 Service，显示结果。
  • AlertDialog：可用于服务错误提示。
  • PopupWindow：可替换通知显示状态。
  • Menu：侧滑菜单控制服务。
  • ViewPager2：显示计数结果。
  • DrawerLayout：导航服务操作。
  • TextWatcher：输入控制服务或语言切换。
  • Configuration：处理屏幕旋转。
  • Gestures：单击控制服务启停。

7. 可能的其他意图

  • 复杂任务：如需文件下载、音乐播放等 Service 场景，请说明。
  • 通信方式：如需 AIDL、Messenger 等，请提供细节。
  • 问题调试：如有崩溃、服务不启动等问题，请描述。
  • 现代替代：如需 WorkManager 或 JobScheduler 示例，请说明。

下一步

请提供更多细节，例如：

  • 你想实现的 Service 功能（定时任务、下载、跨进程通信）？
  • 是否需要特定组件集成（如 RecyclerView 与 Service）？
  • 是否有生命周期或性能问题？
  • 需要更复杂示例（如 AIDL 绑定）？

如果没有进一步信息，我可以提供更详细的 Service 示例（如文件下载服务）或现代替代方案（如 WorkManager）。

网站 http://yingjuxia.com
文章已创建 2371

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

相关文章

开始在上面输入您的搜索词，然后按回车进行搜索。按ESC取消。

返回顶部