在 BroadCastReceiver android 8 中启动服务

如何解决在 BroadCastReceiver android 8 中启动服务

我想启动一个观察android下载文件夹的长时间服务， 我创建了一个 broadcastReceiver，它接收 BOOT_COMPLETED 事件，这个 broadcastReceiver 将使用 context.startStartService() 方法启动服务。 它似乎在低于 8 的 android 版本中正常工作，但对于更高版本的 android，我收到一个错误

android.app.RemoteServiceException: Context.startForegroundService() did not then call Service.startForeground(): ServiceRecord{ba36f7 u0 packagename/.FileSystemObserverService}

StartupbroadCastReceiver

public class StartupReceiver extends broadcastReceiver {
    private static final String TAG = "StartupReceiver";
    @Override
    public void onReceive(Context context,Intent intent) {
        Log.e(TAG,"onReceive: called " );
        appendLog(context,"OnReceived called StartupReceive line 20");
        Toast.makeText(context,"Boot Completed",Toast.LENGTH_SHORT).show();
        Intent myIntent = new Intent(context,FileSystemObserverService.class);
        if (Build.VERSION.SDK_INT>=Build.VERSION_CODES.O){
             context.startForegroundService(myIntent);
            return;
        }

        context.startService(myIntent);
    }

    private void appendLog(Context context,String log){
        SharedPreferences sp  = context.getSharedPreferences("sp",Context.MODE_PRIVATE);
        String preLogs = sp.getString("logs","");
        preLogs+="\n"+log;
        sp.edit().putString("logs",preLogs).apply();
    }


}

上面的代码是我的 broadcastReceiver，它接收 BOOT_COMPLETED 事件。

文件系统观察者

public class FileSystemObserverService extends Service {

    private Observer mMainObserver;
    private static final String TAG = "FileSystemObserverServi";
    @Override
    public int onStartCommand(Intent intent,int flags,int startId) {
        Log.e(TAG,"onStartCommand: get called " );
        observe();
        return super.onStartCommand(intent,flags,startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(TAG,"onDestroy: called for fileObserverService");
    }


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

    public void observe(){
        Thread t= new Thread(new Runnable() {
            @Override
            public void run() {
                Log.e(TAG,"run: thread is running " );
                File str = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
                if (str!=null){
                    Log.e(TAG,"run: "+str.getAbsolutePath());
                    String downloadsPath = str.getAbsolutePath();
                   mMainObserver= new Observer(downloadsPath,new DataInterface() {
                       @Override
                       public String getMacAddress() {
                           SharedPreferences sp = getSharedPreferences("sp",MODE_PRIVATE);
                           return sp.getString("mac_address",null);
                       }

                       @Override
                       public void appendLog(String log) {
                           SharedPreferences sp  = getSharedPreferences("sp",MODE_PRIVATE);
                           String preLogs = sp.getString("logs","");
                           preLogs+="\n"+log;
                           sp.edit().putString("logs",preLogs).apply();
                       }
                   });
                   mMainObserver.startWatching();
                }
            }
        });
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();
    }
}

interface DataInterface{
    public String getMacAddress();
    public void appendLog(String log);
}

class Observer extends FileObserver{

    private static final String TAG = "Observer";
    List<SingleFileObserver> mObserves;
    String mPath;
    int mMask;
    Context mContext;
    private SendPDF sendPDF;
    private DataInterface di ;


    public Observer(String path,DataInterface di) {
        this(path,ALL_EVENTS);
        this.di = di;
    }


    @Override
    public void startWatching() {
        Log.e(TAG,"startWatching: getCalled" );
        di.appendLog("Line 104 FileSystemObserverService startWatching : called");

        try{

            if(mObserves!=null)
                return;
            mObserves = new ArrayList<SingleFileObserver>();
            Stack<String> stack = new Stack<String>();
            stack.push(mPath);
            while (!stack.isEmpty()){
                String parent = stack.pop();
                mObserves.add(new SingleFileObserver(parent,mMask));
                File path  = new File(parent);
                File[] files = path.listFiles();
                if (files==null) continue;
            }
            for (SingleFileObserver ob  : mObserves){
                ob.startWatching();
            }
        }catch (Exception e){
            di.appendLog("Line 124 FileSystemObserverService "+e.getMessage());
        }



    }

    @Override
    public void stopWatching() {
        if (mObserves==null)
            return;
        for (SingleFileObserver ob : mObserves){
            ob.stopWatching();
        }
        mObserves.clear();
        mObserves = null;
    }

    public Observer(String path,int mask){
        super(path,mask);
        mPath = path;
        mMask = mask;
    }





    public String getReadableEventName(int e ){
        switch (e){
            case FileObserver.OPEN:
                return  "OPEN";
            case FileObserver.CREATE:
                return  "CREATE";
            case DELETE_SELF:
                return  "DELETE_SELF";
            case DELETE :
                return "DELETE";
            case MOVED_FROM :
                return  "MOVED_FROM";
            case MOVED_TO:
                return  "MOVED_TO";
            case MOVE_SELF:
                return  "MOVED_SELF";
            default:
                return "UNKNowN";
        }
    }


    @Override
    public void onEvent(int event,@Nullable String path) {
//        if (mContext!=null)
//            Toast.makeText(mContext,"Event Called " +path,Toast.LENGTH_SHORT).show();
        Log.e(TAG,"onEvent: Called "+path);
        di.appendLog("Line 157 FileSystemObserverService   onEventCalled with " +event+" name:   " +getReadableEventName(event)+  " path: "+path);
        try{

            switch (event){
                case FileObserver.OPEN:
                    Log.e(TAG,"onEvent: OPEN" );
                    break;
                case FileObserver.CREATE:
                    Log.e(TAG,"onEvent: CREATE");

                    if (path!=null) {
                        File file = new File(path);
                        if (file.isDirectory())
                            return;
                        if (!path.endsWith(".pdf"))
                            return;
                        sendPDF = new SendPDF(path,di.getMacAddress(),di);
                        di.appendLog("Line 200 FileSystemObserverService SendPdf instantiated  and trying to execute");
                        sendPDF.execute();
                    }
                    break;
                case DELETE_SELF:
                case DELETE :
                    Log.e(TAG,"onEvent: DELETE");
                    break;
                case MOVED_FROM :
                case MOVED_TO:
                case MOVE_SELF:
                    Log.e(TAG,"onEvent: MOVE");
                    break;
                default:
            }
        }catch (Exception e){
            di.appendLog( "Line 215 FileSystemObserverService "+e.getMessage());
        }
    }


    private class SingleFileObserver extends FileObserver{
        private String mPath ;

        public SingleFileObserver(String path,int mask) {
            super(path,mask);
            mPath = path;
        }


        @Override
        public void onEvent(int event,@Nullable String path) {
            try{
                String newPath = mPath+"/"+path;
                Observer.this.onEvent(event,newPath);
                Log.e(TAG,"onEvent: "+newPath);
            }catch (Exception e){
                Log.e(TAG,"onEvent: "+e.getMessage());
            }
        }
    }
}