TruCred v1.1.3 - TransferService.java 源代码

package com.amazonaws.mobileconnectors.s3.transferutility;

import android.app.Service;
import android.content.Intent;
import android.content.IntentFilter;
import android.database.ContentObserver;
import android.database.Cursor;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Message;
import android.util.Log;
import androidx.recyclerview.widget.ItemTouchHelper;
import com.amazonaws.mobileconnectors.s3.transferutility.networkinfo.NetworkInfoChangeListener;
import com.amazonaws.mobileconnectors.s3.transferutility.networkinfo.NetworkInfoReceiver;
import com.amazonaws.services.s3.AmazonS3;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

public class TransferService extends Service {
    private TransferDBUtil dbUtil;
    private HandlerThread handlerThread;
    private final Handler.Callback mUpdateCallback = new Handler.Callback() {
        @Override
        public boolean handleMessage(Message message) {
            boolean updateTransfersFromDB;
            synchronized (TransferService.this.transfers) {
                updateTransfersFromDB = TransferService.this.updateTransfersFromDB();
            }
            if (updateTransfersFromDB) {
                TransferService.this.enqueueCheckTasksDoneLater();
                return true;
            }
            if (message.what != 200) {
                return true;
            }
            TransferService transferService = TransferService.this;
            transferService.stopSelf(transferService.startId);
            return true;
        }
    };
    private NetworkInfoReceiver networkInfoReceive;
    private TransferContentObserver observer;
    private AmazonS3 s3;
    private int startId;
    private Map<Integer, TransferRecord> transfers;
    private Handler updateHandler;

    public class TransferContentObserver extends ContentObserver {
        public TransferContentObserver() {
            super(new Handler());
        }

        @Override
        public void onChange(boolean z) {
            TransferService.this.enqueueUpdate();
        }
    }

    private TransferRecord addNewTransfer(Cursor cursor) {
        TransferRecord transferRecord = new TransferRecord(cursor.getInt(cursor.getColumnIndexOrThrow("_id")), this.s3);
        transferRecord.updateFromDB(cursor);
        this.transfers.put(Integer.valueOf(transferRecord.id), transferRecord);
        return transferRecord;
    }

    public void enqueueCheckTasksDoneLater() {
        this.updateHandler.removeMessages(ItemTouchHelper.Callback.DEFAULT_DRAG_ANIMATION_DURATION);
        Handler handler = this.updateHandler;
        handler.sendMessageDelayed(handler.obtainMessage(ItemTouchHelper.Callback.DEFAULT_DRAG_ANIMATION_DURATION, Integer.valueOf(this.startId)), 60000L);
    }

    public void enqueueUpdate() {
        this.updateHandler.removeMessages(100);
        this.updateHandler.obtainMessage(100, Integer.valueOf(this.startId)).sendToTarget();
    }

    @Override
    public IBinder onBind(Intent intent) {
        throw new UnsupportedOperationException("Can't bind to TransferSerivce");
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d("TransferSerivce", "Starting Transfer Service");
        this.transfers = new HashMap();
        HandlerThread handlerThread = new HandlerThread("TransferSerivce-AWSTransferUpdateHandlerThread");
        this.handlerThread = handlerThread;
        handlerThread.start();
        this.updateHandler = new Handler(this.handlerThread.getLooper(), this.mUpdateCallback);
        this.dbUtil = new TransferDBUtil(getApplicationContext());
        this.observer = new TransferContentObserver();
        getContentResolver().registerContentObserver(this.dbUtil.getContentUri(), true, this.observer);
        NetworkInfoReceiver networkInfoReceiver = new NetworkInfoReceiver(getApplicationContext());
        this.networkInfoReceive = networkInfoReceiver;
        networkInfoReceiver.addNetworkInfoListener(new NetworkInfoChangeListener() {
            @Override
            public void onConnect() {
                TransferService.this.dbUtil.updateNetworkConnected();
            }

            @Override
            public void onDisconnect() {
                TransferService.this.dbUtil.updateNetworkDisconnected();
            }
        });
        if (this.networkInfoReceive.isNetworkConnected()) {
            this.dbUtil.updateNetworkConnected();
        } else {
            this.dbUtil.updateNetworkDisconnected();
        }
        registerReceiver(this.networkInfoReceive, new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE"));
    }

    @Override
    public void onDestroy() {
        getContentResolver().unregisterContentObserver(this.observer);
        unregisterReceiver(this.networkInfoReceive);
        this.handlerThread.quit();
        this.dbUtil.setAllRunningRecordsToPausedBeforeShutdownService();
        TransferThreadPool.closeThreadPool();
        super.onDestroy();
    }

    @Override
    public int onStartCommand(Intent intent, int i2, int i3) {
        this.startId = i3;
        AmazonS3 amazonS3 = S3ClientWeakReference.get(intent.getStringExtra("keyForS3WeakReference"));
        this.s3 = amazonS3;
        if (amazonS3 == null) {
            Log.w("TransferSerivce", "TransferService can't get s3 client, it will stop.");
            stopSelf();
        }
        enqueueUpdate();
        return 2;
    }

    public boolean updateTransfersFromDB() {
        HashSet<Integer> hashSet = new HashSet(this.transfers.keySet());
        Cursor queryAllTransfersWithType = this.dbUtil.queryAllTransfersWithType(TransferType.ANY);
        boolean z = false;
        while (queryAllTransfersWithType.moveToNext()) {
            int i2 = queryAllTransfersWithType.getInt(queryAllTransfersWithType.getColumnIndexOrThrow("_id"));
            hashSet.remove(Integer.valueOf(i2));
            TransferRecord transferRecord = this.transfers.get(Integer.valueOf(i2));
            if (transferRecord != null) {
                transferRecord.updateFromDB(queryAllTransfersWithType);
            } else {
                transferRecord = addNewTransfer(queryAllTransfersWithType);
            }
            boolean startIfReady = transferRecord.startIfReady(this.dbUtil);
            transferRecord.pauseOrCancelIfRequested(this.dbUtil);
            z |= startIfReady;
        }
        queryAllTransfersWithType.close();
        for (Integer num : hashSet) {
            num.intValue();
            this.transfers.remove(num);
        }
        return z;
    }
}