コード例 #1
0
ファイル: SwitchLog.java プロジェクト: gcb/android-CPU-tuner
  @Override
  public void onReceive(Context context, Intent intent) {
    if (!SettingsStorage.getInstance().isEnableLogProfileSwitches()) {
      return;
    }
    if (intent == null) {
      return;
    }
    if (ACTION_FLUSH_LOG.equals(intent.getAction())
        || intent.getBooleanExtra(ACTION_FLUSH_LOG, false)) {
      flushLogToDB(context);
      return;
    }
    ContentValues values = new ContentValues();
    values.put(DB.SwitchLogDB.NAME_TIME, System.currentTimeMillis());
    values.put(DB.SwitchLogDB.NAME_MESSAGE, intent.getStringExtra(EXTRA_LOG_ENTRY));
    values.put(DB.SwitchLogDB.NAME_TRIGGER, intent.getStringExtra(DB.SwitchLogDB.NAME_TRIGGER));
    values.put(DB.SwitchLogDB.NAME_PROFILE, intent.getStringExtra(DB.SwitchLogDB.NAME_PROFILE));
    values.put(DB.SwitchLogDB.NAME_VIRTGOV, intent.getStringExtra(DB.SwitchLogDB.NAME_VIRTGOV));
    values.put(DB.SwitchLogDB.NAME_AC, intent.getIntExtra(DB.SwitchLogDB.NAME_AC, -1));
    values.put(DB.SwitchLogDB.NAME_BATTERY, intent.getIntExtra(DB.SwitchLogDB.NAME_BATTERY, -1));
    values.put(DB.SwitchLogDB.NAME_CALL, intent.getIntExtra(DB.SwitchLogDB.NAME_CALL, -1));
    values.put(DB.SwitchLogDB.NAME_HOT, intent.getIntExtra(DB.SwitchLogDB.NAME_HOT, -1));
    values.put(DB.SwitchLogDB.NAME_LOCKED, intent.getIntExtra(DB.SwitchLogDB.NAME_LOCKED, -1));

    Builder opp = ContentProviderOperation.newInsert(DB.SwitchLogDB.CONTENT_URI);
    opp.withValues(values);
    operations.add(opp.build());
    if (operations.size() > 10 || intent.getBooleanExtra(EXTRA_FLUSH_LOG, false)) {
      flushLogToDB(context);
    }
  }
  /**
   * Build a list of {@link ContentProviderOperation} that will transform all the "before" {@link
   * Entity} states into the modified state which all {@link EntityDelta} objects represent. This
   * method specifically creates any {@link AggregationExceptions} rules needed to groups edits
   * together.
   */
  public ArrayList<ContentProviderOperation> buildDiff() {
    final ArrayList<ContentProviderOperation> diff = Lists.newArrayList();

    final long rawContactId = this.findRawContactId();
    int firstInsertRow = -1;

    // First pass enforces versions remain consistent
    for (EntityDelta delta : this) {
      delta.buildAssert(diff);
    }

    final int assertMark = diff.size();
    int backRefs[] = new int[size()];

    int rawContactIndex = 0;

    // Second pass builds actual operations
    for (EntityDelta delta : this) {
      final int firstBatch = diff.size();
      backRefs[rawContactIndex++] = firstBatch;
      delta.buildDiff(diff);

      // Only create rules for inserts
      if (!delta.isContactInsert()) continue;

      // If we are going to split all contacts, there is no point in first combining them
      if (mSplitRawContacts) continue;

      if (rawContactId != -1) {
        // Has existing contact, so bind to it strongly
        final Builder builder = beginKeepTogether();
        builder.withValue(AggregationExceptions.RAW_CONTACT_ID1, rawContactId);
        builder.withValueBackReference(AggregationExceptions.RAW_CONTACT_ID2, firstBatch);
        diff.add(builder.build());

      } else if (firstInsertRow == -1) {
        // First insert case, so record row
        firstInsertRow = firstBatch;

      } else {
        // Additional insert case, so point at first insert
        final Builder builder = beginKeepTogether();
        builder.withValueBackReference(AggregationExceptions.RAW_CONTACT_ID1, firstInsertRow);
        builder.withValueBackReference(AggregationExceptions.RAW_CONTACT_ID2, firstBatch);
        diff.add(builder.build());
      }
    }

    if (mSplitRawContacts) {
      buildSplitContactDiff(diff, backRefs);
    }

    // No real changes if only left with asserts
    if (diff.size() == assertMark) {
      diff.clear();
    }

    return diff;
  }
コード例 #3
0
ファイル: SwitchLog.java プロジェクト: gcb/android-CPU-tuner
  private void flushLogToDB(Context context) {
    try {
      int logSize = SettingsStorage.getInstance().getProfileSwitchLogSize();
      if (logSize > -1) {
        Builder opp = ContentProviderOperation.newDelete(DB.SwitchLogDB.CONTENT_URI);
        String time = Long.toString(System.currentTimeMillis() - (logSize * HOURS_IN_MILLIES));
        opp.withSelection(DB.SwitchLogDB.SELECTION_BY_TIME, new String[] {time});
        operations.add(opp.build());
      }

      context.getContentResolver().applyBatch(CpuTunerProvider.AUTHORITY, operations);
      operations.clear();
    } catch (Exception e) {
      Logger.w("Cannot flush to switch log");
    }
  }
コード例 #4
0
  public void deleteAllExceptRemoteNames(Resource[] remoteResources) {
    String where;

    if (remoteResources.length != 0) {
      List<String> sqlFileNames = new LinkedList<String>();
      for (Resource res : remoteResources)
        sqlFileNames.add(DatabaseUtils.sqlEscapeString(res.getName()));
      where = entryColumnRemoteName() + " NOT IN (" + StringUtils.join(sqlFileNames, ",") + ")";
    } else where = entryColumnRemoteName() + " IS NOT NULL";

    Builder builder =
        ContentProviderOperation.newDelete(entriesURI())
            .withSelection(
                entryColumnParentID() + "=? AND (" + where + ")",
                new String[] {String.valueOf(id)});
    pendingOperations.add(builder.withYieldAllowed(true).build());
  }
コード例 #5
0
  protected Builder buildReminder(Builder builder, VAlarm alarm) {
    int minutes = 0;

    Dur duration;
    if (alarm.getTrigger() != null && (duration = alarm.getTrigger().getDuration()) != null)
      minutes = duration.getDays() * 24 * 60 + duration.getHours() * 60 + duration.getMinutes();

    Log.d(TAG, "Adding alarm " + minutes + " min before");

    return builder
        .withValue(Reminders.METHOD, Reminders.METHOD_ALERT)
        .withValue(Reminders.MINUTES, minutes);
  }
コード例 #6
0
  @SuppressLint("InlinedApi")
  protected Builder buildAttendee(Builder builder, Attendee attendee) {
    Uri member = Uri.parse(attendee.getValue());
    String email = member.getSchemeSpecificPart();

    Cn cn = (Cn) attendee.getParameter(Parameter.CN);
    if (cn != null) builder = builder.withValue(Attendees.ATTENDEE_NAME, cn.getValue());

    int type = Attendees.TYPE_NONE;

    CuType cutype = (CuType) attendee.getParameter(Parameter.CUTYPE);
    if (cutype == CuType.RESOURCE) type = Attendees.TYPE_RESOURCE;
    else {
      Role role = (Role) attendee.getParameter(Parameter.ROLE);
      int relationship;
      if (role == Role.CHAIR) relationship = Attendees.RELATIONSHIP_ORGANIZER;
      else {
        relationship = Attendees.RELATIONSHIP_ATTENDEE;
        if (role == Role.OPT_PARTICIPANT) type = Attendees.TYPE_OPTIONAL;
        else if (role == Role.REQ_PARTICIPANT) type = Attendees.TYPE_REQUIRED;
      }
      builder = builder.withValue(Attendees.ATTENDEE_RELATIONSHIP, relationship);
    }

    int status = Attendees.ATTENDEE_STATUS_NONE;
    PartStat partStat = (PartStat) attendee.getParameter(Parameter.PARTSTAT);
    if (partStat == null || partStat == PartStat.NEEDS_ACTION)
      status = Attendees.ATTENDEE_STATUS_INVITED;
    else if (partStat == PartStat.ACCEPTED) status = Attendees.ATTENDEE_STATUS_ACCEPTED;
    else if (partStat == PartStat.DECLINED) status = Attendees.ATTENDEE_STATUS_DECLINED;
    else if (partStat == PartStat.TENTATIVE) status = Attendees.ATTENDEE_STATUS_TENTATIVE;

    return builder
        .withValue(Attendees.ATTENDEE_EMAIL, email)
        .withValue(Attendees.ATTENDEE_TYPE, type)
        .withValue(Attendees.ATTENDEE_STATUS, status);
  }
  /** Construct a {@link AggregationExceptions#TYPE_KEEP_SEPARATE}. */
  private void buildSplitContactDiff(
      ArrayList<ContentProviderOperation> diff, int index1, int index2, int[] backRefs) {
    Builder builder = ContentProviderOperation.newUpdate(AggregationExceptions.CONTENT_URI);
    builder.withValue(AggregationExceptions.TYPE, AggregationExceptions.TYPE_KEEP_SEPARATE);

    Long rawContactId1 = get(index1).getValues().getAsLong(RawContacts._ID);
    if (rawContactId1 != null && rawContactId1 >= 0) {
      builder.withValue(AggregationExceptions.RAW_CONTACT_ID1, rawContactId1);
    } else {
      builder.withValueBackReference(AggregationExceptions.RAW_CONTACT_ID1, backRefs[index1]);
    }

    Long rawContactId2 = get(index2).getValues().getAsLong(RawContacts._ID);
    if (rawContactId2 != null && rawContactId2 >= 0) {
      builder.withValue(AggregationExceptions.RAW_CONTACT_ID2, rawContactId2);
    } else {
      builder.withValueBackReference(AggregationExceptions.RAW_CONTACT_ID2, backRefs[index2]);
    }
    diff.add(builder.build());
  }
コード例 #8
0
 /**
  * Build a {@link ContentProviderOperation} that changes {@link RawContacts#AGGREGATION_MODE} to
  * the given value.
  */
 protected Builder buildSetAggregationMode(Long beforeId, int mode) {
   Builder builder = ContentProviderOperation.newUpdate(mContactsQueryUri);
   builder.withValue(RawContacts.AGGREGATION_MODE, mode);
   builder.withSelection(RawContacts._ID + "=" + beforeId, null);
   return builder;
 }
コード例 #9
0
  /**
   * For compatibility purpose, this method is copied from {@link #buildDiff} and takes an ArrayList
   * of CPOWrapper as parameter.
   */
  public void buildDiffWrapper(ArrayList<CPOWrapper> buildInto) {
    final int firstIndex = buildInto.size();

    final boolean isContactInsert = mValues.isInsert();
    final boolean isContactDelete = mValues.isDelete();
    final boolean isContactUpdate = !isContactInsert && !isContactDelete;

    final Long beforeId = mValues.getId();

    if (isContactInsert) {
      // TODO: for now simply disabling aggregation when a new contact is
      // created on the phone.  In the future, will show aggregation suggestions
      // after saving the contact.
      mValues.put(RawContacts.AGGREGATION_MODE, RawContacts.AGGREGATION_MODE_SUSPENDED);
    }

    // Build possible operation at Contact level
    BuilderWrapper bw = mValues.buildDiffWrapper(mContactsQueryUri);
    possibleAddWrapper(buildInto, bw);

    // Build operations for all children
    for (ArrayList<ValuesDelta> mimeEntries : mEntries.values()) {
      for (ValuesDelta child : mimeEntries) {
        // Ignore children if parent was deleted
        if (isContactDelete) continue;

        // Use the profile data URI if the contact is the profile.
        if (mContactsQueryUri.equals(Profile.CONTENT_RAW_CONTACTS_URI)) {
          bw =
              child.buildDiffWrapper(
                  Uri.withAppendedPath(Profile.CONTENT_URI, RawContacts.Data.CONTENT_DIRECTORY));
        } else {
          bw = child.buildDiffWrapper(Data.CONTENT_URI);
        }

        if (child.isInsert()) {
          if (isContactInsert) {
            // Parent is brand new insert, so back-reference _id
            bw.getBuilder().withValueBackReference(Data.RAW_CONTACT_ID, firstIndex);
          } else {
            // Inserting under existing, so fill with known _id
            bw.getBuilder().withValue(Data.RAW_CONTACT_ID, beforeId);
          }
        } else if (isContactInsert && bw != null && bw.getBuilder() != null) {
          // Child must be insert when Contact insert
          throw new IllegalArgumentException("When parent insert, child must be also");
        }
        possibleAddWrapper(buildInto, bw);
      }
    }

    final boolean addedOperations = buildInto.size() > firstIndex;
    if (addedOperations && isContactUpdate) {
      // Suspend aggregation while persisting updates
      Builder builder = buildSetAggregationMode(beforeId, RawContacts.AGGREGATION_MODE_SUSPENDED);
      buildInto.add(firstIndex, new CPOWrapper(builder.build(), CompatUtils.TYPE_UPDATE));

      // Restore aggregation mode as last operation
      builder = buildSetAggregationMode(beforeId, RawContacts.AGGREGATION_MODE_DEFAULT);
      buildInto.add(new CPOWrapper(builder.build(), CompatUtils.TYPE_UPDATE));
    } else if (isContactInsert) {
      // Restore aggregation mode as last operation
      Builder builder = ContentProviderOperation.newUpdate(mContactsQueryUri);
      builder.withValue(RawContacts.AGGREGATION_MODE, RawContacts.AGGREGATION_MODE_DEFAULT);
      builder.withSelection(RawContacts._ID + "=?", new String[1]);
      builder.withSelectionBackReference(0, firstIndex);
      buildInto.add(new CPOWrapper(builder.build(), CompatUtils.TYPE_UPDATE));
    }
  }
コード例 #10
0
 /**
  * For compatibility purpose, this method is copied from {@link #buildAssert} and takes an
  * ArrayList of CPOWrapper as parameter.
  */
 public void buildAssertWrapper(ArrayList<CPOWrapper> buildInto) {
   final Builder builder = buildAssertHelper();
   if (builder != null) {
     buildInto.add(new CPOWrapper(builder.build(), CompatUtils.TYPE_ASSERT));
   }
 }
コード例 #11
0
 /**
  * Build a list of {@link ContentProviderOperation} that will assert any "before" state hasn't
  * changed. This is maintained separately so that all asserts can take place before any updates
  * occur.
  */
 public void buildAssert(ArrayList<ContentProviderOperation> buildInto) {
   final Builder builder = buildAssertHelper();
   if (builder != null) {
     buildInto.add(builder.build());
   }
 }
コード例 #12
0
  @Override
  protected Builder buildEntry(Builder builder, Resource resource) {
    Event event = (Event) resource;

    builder =
        builder
            .withValue(Events.CALENDAR_ID, id)
            .withValue(entryColumnRemoteName(), event.getName())
            .withValue(entryColumnETag(), event.getETag())
            .withValue(entryColumnUID(), event.getUid())
            .withValue(Events.ALL_DAY, event.isAllDay() ? 1 : 0)
            .withValue(Events.DTSTART, event.getDtStartInMillis())
            .withValue(Events.EVENT_TIMEZONE, event.getDtStartTzID())
            .withValue(Events.HAS_ATTENDEE_DATA, event.getAttendees().isEmpty() ? 0 : 1)
            .withValue(Events.GUESTS_CAN_INVITE_OTHERS, 1)
            .withValue(Events.GUESTS_CAN_MODIFY, 1)
            .withValue(Events.GUESTS_CAN_SEE_GUESTS, 1);

    boolean recurring = false;
    if (event.getRrule() != null) {
      recurring = true;
      builder = builder.withValue(Events.RRULE, event.getRrule().getValue());
    }
    if (event.getRdate() != null) {
      recurring = true;
      builder = builder.withValue(Events.RDATE, event.getRdate().getValue());
    }
    if (event.getExrule() != null)
      builder = builder.withValue(Events.EXRULE, event.getExrule().getValue());
    if (event.getExdate() != null)
      builder = builder.withValue(Events.EXDATE, event.getExdate().getValue());

    // set either DTEND for single-time events or DURATION for recurring events
    // because that's the way Android likes it (see docs)
    if (recurring) {
      // calculate DURATION from start and end date
      Duration duration = new Duration(event.getDtStart().getDate(), event.getDtEnd().getDate());
      builder = builder.withValue(Events.DURATION, duration.getValue());
    } else {
      builder =
          builder
              .withValue(Events.DTEND, event.getDtEndInMillis())
              .withValue(Events.EVENT_END_TIMEZONE, event.getDtEndTzID());
    }

    if (event.getSummary() != null) builder = builder.withValue(Events.TITLE, event.getSummary());
    if (event.getLocation() != null)
      builder = builder.withValue(Events.EVENT_LOCATION, event.getLocation());
    if (event.getDescription() != null)
      builder = builder.withValue(Events.DESCRIPTION, event.getDescription());

    if (event.getOrganizer() != null && event.getOrganizer().getCalAddress() != null) {
      URI organizer = event.getOrganizer().getCalAddress();
      if (organizer.getScheme() != null && organizer.getScheme().equalsIgnoreCase("mailto"))
        builder = builder.withValue(Events.ORGANIZER, organizer.getSchemeSpecificPart());
    }

    Status status = event.getStatus();
    if (status != null) {
      int statusCode = Events.STATUS_TENTATIVE;
      if (status == Status.VEVENT_CONFIRMED) statusCode = Events.STATUS_CONFIRMED;
      else if (status == Status.VEVENT_CANCELLED) statusCode = Events.STATUS_CANCELED;
      builder = builder.withValue(Events.STATUS, statusCode);
    }

    builder =
        builder.withValue(
            Events.AVAILABILITY,
            event.isOpaque() ? Events.AVAILABILITY_BUSY : Events.AVAILABILITY_FREE);

    if (event.getForPublic() != null)
      builder =
          builder.withValue(
              Events.ACCESS_LEVEL,
              event.getForPublic() ? Events.ACCESS_PUBLIC : Events.ACCESS_PRIVATE);

    return builder;
  }
 /**
  * Start building a {@link ContentProviderOperation} that will keep two {@link RawContacts}
  * together.
  */
 protected Builder beginKeepTogether() {
   final Builder builder = ContentProviderOperation.newUpdate(AggregationExceptions.CONTENT_URI);
   builder.withValue(AggregationExceptions.TYPE, AggregationExceptions.TYPE_KEEP_TOGETHER);
   return builder;
 }