Examples with AtomicFile android.util.AtomicFile used on opensource projects

Example 26 with AtomicFile

use of android.util.AtomicFile in project platform_frameworks_base by android.

the class ProcessStatsService method updateFile.

private void updateFile() {
    mFile = new AtomicFile(new File(mBaseDir, STATE_FILE_PREFIX + mProcessStats.mTimePeriodStartClockStr + STATE_FILE_SUFFIX));
    mLastWriteTime = SystemClock.uptimeMillis();
}

Example 27 with AtomicFile

use of android.util.AtomicFile in project platform_frameworks_base by android.

the class ProcessStatsService method performWriteState.

void performWriteState() {
    if (DEBUG)
        Slog.d(TAG, "Performing write to " + mFile.getBaseFile());
    Parcel data;
    AtomicFile file;
    synchronized (mPendingWriteLock) {
        data = mPendingWrite;
        file = mPendingWriteFile;
        mPendingWriteCommitted = false;
        if (data == null) {
            return;
        }
        mPendingWrite = null;
        mPendingWriteFile = null;
        mWriteLock.lock();
    }
    FileOutputStream stream = null;
    try {
        stream = file.startWrite();
        stream.write(data.marshall());
        stream.flush();
        file.finishWrite(stream);
        if (DEBUG)
            Slog.d(TAG, "Write completed successfully!");
    } catch (IOException e) {
        Slog.w(TAG, "Error writing process statistics", e);
        file.failWrite(stream);
    } finally {
        data.recycle();
        trimHistoricStatesWriteLocked();
        mWriteLock.unlock();
    }
}

Example 28 with AtomicFile

use of android.util.AtomicFile in project platform_frameworks_base by android.

the class ProcessStatsService method getStatsOverTime.

public ParcelFileDescriptor getStatsOverTime(long minTime) {
    mAm.mContext.enforceCallingOrSelfPermission(android.Manifest.permission.PACKAGE_USAGE_STATS, null);
    Parcel current = Parcel.obtain();
    long curTime;
    synchronized (mAm) {
        long now = SystemClock.uptimeMillis();
        mProcessStats.mTimePeriodEndRealtime = SystemClock.elapsedRealtime();
        mProcessStats.mTimePeriodEndUptime = now;
        mProcessStats.writeToParcel(current, now, 0);
        curTime = mProcessStats.mTimePeriodEndRealtime - mProcessStats.mTimePeriodStartRealtime;
    }
    mWriteLock.lock();
    try {
        if (curTime < minTime) {
            // Need to add in older stats to reach desired time.
            ArrayList<String> files = getCommittedFiles(0, false, true);
            if (files != null && files.size() > 0) {
                current.setDataPosition(0);
                ProcessStats stats = ProcessStats.CREATOR.createFromParcel(current);
                current.recycle();
                int i = files.size() - 1;
                while (i >= 0 && (stats.mTimePeriodEndRealtime - stats.mTimePeriodStartRealtime) < minTime) {
                    AtomicFile file = new AtomicFile(new File(files.get(i)));
                    i--;
                    ProcessStats moreStats = new ProcessStats(false);
                    readLocked(moreStats, file);
                    if (moreStats.mReadError == null) {
                        stats.add(moreStats);
                        StringBuilder sb = new StringBuilder();
                        sb.append("Added stats: ");
                        sb.append(moreStats.mTimePeriodStartClockStr);
                        sb.append(", over ");
                        TimeUtils.formatDuration(moreStats.mTimePeriodEndRealtime - moreStats.mTimePeriodStartRealtime, sb);
                        Slog.i(TAG, sb.toString());
                    } else {
                        Slog.w(TAG, "Failure reading " + files.get(i + 1) + "; " + moreStats.mReadError);
                        continue;
                    }
                }
                current = Parcel.obtain();
                stats.writeToParcel(current, 0);
            }
        }
        final byte[] outData = current.marshall();
        current.recycle();
        final ParcelFileDescriptor[] fds = ParcelFileDescriptor.createPipe();
        Thread thr = new Thread("ProcessStats pipe output") {

            public void run() {
                FileOutputStream fout = new ParcelFileDescriptor.AutoCloseOutputStream(fds[1]);
                try {
                    fout.write(outData);
                    fout.close();
                } catch (IOException e) {
                    Slog.w(TAG, "Failure writing pipe", e);
                }
            }
        };
        thr.start();
        return fds[0];
    } catch (IOException e) {
        Slog.w(TAG, "Failed building output pipe", e);
    } finally {
        mWriteLock.unlock();
    }
    return null;
}

Example 29 with AtomicFile

use of android.util.AtomicFile in project platform_frameworks_base by android.

the class NotificationManagerService method onStart.

@Override
public void onStart() {
    Resources resources = getContext().getResources();
    mMaxPackageEnqueueRate = Settings.Global.getFloat(getContext().getContentResolver(), Settings.Global.MAX_NOTIFICATION_ENQUEUE_RATE, DEFAULT_MAX_NOTIFICATION_ENQUEUE_RATE);
    mAm = ActivityManagerNative.getDefault();
    mAppOps = (AppOpsManager) getContext().getSystemService(Context.APP_OPS_SERVICE);
    mVibrator = (Vibrator) getContext().getSystemService(Context.VIBRATOR_SERVICE);
    mAppUsageStats = LocalServices.getService(UsageStatsManagerInternal.class);
    // This is the package that contains the AOSP framework update.
    mRankerServicePackageName = getContext().getPackageManager().getServicesSystemSharedLibraryPackageName();
    mHandler = new WorkerHandler();
    mRankingThread.start();
    String[] extractorNames;
    try {
        extractorNames = resources.getStringArray(R.array.config_notificationSignalExtractors);
    } catch (Resources.NotFoundException e) {
        extractorNames = new String[0];
    }
    mUsageStats = new NotificationUsageStats(getContext());
    mRankingHandler = new RankingHandlerWorker(mRankingThread.getLooper());
    mRankingHelper = new RankingHelper(getContext(), mRankingHandler, mUsageStats, extractorNames);
    mConditionProviders = new ConditionProviders(getContext(), mHandler, mUserProfiles);
    mZenModeHelper = new ZenModeHelper(getContext(), mHandler.getLooper(), mConditionProviders);
    mZenModeHelper.addCallback(new ZenModeHelper.Callback() {

        @Override
        public void onConfigChanged() {
            savePolicyFile();
        }

        @Override
        void onZenModeChanged() {
            sendRegisteredOnlyBroadcast(NotificationManager.ACTION_INTERRUPTION_FILTER_CHANGED);
            getContext().sendBroadcastAsUser(new Intent(NotificationManager.ACTION_INTERRUPTION_FILTER_CHANGED_INTERNAL).addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT), UserHandle.ALL, android.Manifest.permission.MANAGE_NOTIFICATIONS);
            synchronized (mNotificationList) {
                updateInterruptionFilterLocked();
            }
        }

        @Override
        void onPolicyChanged() {
            sendRegisteredOnlyBroadcast(NotificationManager.ACTION_NOTIFICATION_POLICY_CHANGED);
        }
    });
    final File systemDir = new File(Environment.getDataDirectory(), "system");
    mPolicyFile = new AtomicFile(new File(systemDir, "notification_policy.xml"));
    syncBlockDb();
    // This is a MangedServices object that keeps track of the listeners.
    mListeners = new NotificationListeners();
    // This is a MangedServices object that keeps track of the ranker.
    mRankerServices = new NotificationRankers();
    // Find the updatable ranker and register it.
    mRankerServices.registerRanker();
    mStatusBar = getLocalService(StatusBarManagerInternal.class);
    if (mStatusBar != null) {
        mStatusBar.setNotificationDelegate(mNotificationDelegate);
    }
    final LightsManager lights = getLocalService(LightsManager.class);
    mNotificationLight = lights.getLight(LightsManager.LIGHT_ID_NOTIFICATIONS);
    mAttentionLight = lights.getLight(LightsManager.LIGHT_ID_ATTENTION);
    mDefaultNotificationColor = resources.getColor(R.color.config_defaultNotificationColor);
    mDefaultNotificationLedOn = resources.getInteger(R.integer.config_defaultNotificationLedOn);
    mDefaultNotificationLedOff = resources.getInteger(R.integer.config_defaultNotificationLedOff);
    mDefaultVibrationPattern = getLongArray(resources, R.array.config_defaultNotificationVibePattern, VIBRATE_PATTERN_MAXLEN, DEFAULT_VIBRATE_PATTERN);
    mFallbackVibrationPattern = getLongArray(resources, R.array.config_notificationFallbackVibePattern, VIBRATE_PATTERN_MAXLEN, DEFAULT_VIBRATE_PATTERN);
    mUseAttentionLight = resources.getBoolean(R.bool.config_useAttentionLight);
    // flag at least once and we'll go back to 0 after that.
    if (0 == Settings.Global.getInt(getContext().getContentResolver(), Settings.Global.DEVICE_PROVISIONED, 0)) {
        mDisableNotificationEffects = true;
    }
    mZenModeHelper.initZenMode();
    mInterruptionFilter = mZenModeHelper.getZenModeListenerInterruptionFilter();
    mUserProfiles.updateCache(getContext());
    listenForCallState();
    // register for various Intents
    IntentFilter filter = new IntentFilter();
    filter.addAction(Intent.ACTION_SCREEN_ON);
    filter.addAction(Intent.ACTION_SCREEN_OFF);
    filter.addAction(TelephonyManager.ACTION_PHONE_STATE_CHANGED);
    filter.addAction(Intent.ACTION_USER_PRESENT);
    filter.addAction(Intent.ACTION_USER_STOPPED);
    filter.addAction(Intent.ACTION_USER_SWITCHED);
    filter.addAction(Intent.ACTION_USER_ADDED);
    filter.addAction(Intent.ACTION_USER_REMOVED);
    filter.addAction(Intent.ACTION_USER_UNLOCKED);
    filter.addAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE);
    getContext().registerReceiver(mIntentReceiver, filter);
    IntentFilter pkgFilter = new IntentFilter();
    pkgFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
    pkgFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
    pkgFilter.addAction(Intent.ACTION_PACKAGE_CHANGED);
    pkgFilter.addAction(Intent.ACTION_PACKAGE_RESTARTED);
    pkgFilter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART);
    pkgFilter.addDataScheme("package");
    getContext().registerReceiverAsUser(mPackageIntentReceiver, UserHandle.ALL, pkgFilter, null, null);
    IntentFilter suspendedPkgFilter = new IntentFilter();
    suspendedPkgFilter.addAction(Intent.ACTION_PACKAGES_SUSPENDED);
    getContext().registerReceiverAsUser(mPackageIntentReceiver, UserHandle.ALL, suspendedPkgFilter, null, null);
    IntentFilter sdFilter = new IntentFilter(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
    getContext().registerReceiverAsUser(mPackageIntentReceiver, UserHandle.ALL, sdFilter, null, null);
    mSettingsObserver = new SettingsObserver(mHandler);
    mArchive = new Archive(resources.getInteger(R.integer.config_notificationServiceArchiveSize));
    publishBinderService(Context.NOTIFICATION_SERVICE, mService);
    publishLocalService(NotificationManagerInternal.class, mInternalService);
}

Example 30 with AtomicFile

use of android.util.AtomicFile in project platform_frameworks_base by android.

the class EphemeralApplicationRegistry method parseMetadataFile.

private static UninstalledEphemeralAppState parseMetadataFile(File metadataFile) {
    if (!metadataFile.exists()) {
        return null;
    }
    FileInputStream in;
    try {
        in = new AtomicFile(metadataFile).openRead();
    } catch (FileNotFoundException fnfe) {
        Slog.i(LOG_TAG, "No ephemeral metadata file");
        return null;
    }
    final File ephemeralDir = metadataFile.getParentFile();
    final long timestamp = metadataFile.lastModified();
    final String packageName = ephemeralDir.getName();
    try {
        XmlPullParser parser = Xml.newPullParser();
        parser.setInput(in, StandardCharsets.UTF_8.name());
        return new UninstalledEphemeralAppState(parseMetadata(parser, packageName), timestamp);
    } catch (XmlPullParserException | IOException e) {
        throw new IllegalStateException("Failed parsing ephemeral" + " metadata file: " + metadataFile, e);
    } finally {
        IoUtils.closeQuietly(in);
    }
}