Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 20147323 authored by Ray Essick's avatar Ray Essick
Browse files

C interface to MediaMetrics 

C interface is more stable across upgrades than C++
and simplifies cross-package interfaces in upgradeable components.

Bug: 119675363
Test: parallel metrics generation from nuplayer
Change-Id: I36beeade82a208be64af0860eb6f175a2801b27f
parent 7763cf3b

include/media/MediaMetrics.h

0 → 120000
+1 −0
Original line number Diff line number Diff line 
../../media/libmediametrics/include/MediaMetrics.h
 
 No newline at end of file

media/libmediametrics/Android.bp

+14 −4
Original line number Diff line number Diff line
@@ -6,15 +6,16 @@ cc_library { 
    srcs: [

        "IMediaAnalyticsService.cpp",

        "MediaAnalyticsItem.cpp",

        "MediaMetrics.cpp",

    ],



    shared_libs: [

        "liblog",

        "libcutils",

        "libutils",

        "libbase",

        "libbinder",

        "libcutils",

        "liblog",

        "libstagefright_foundation",

        "libbase",

        "libutils",

    ],



    export_include_dirs: ["include"],
@@ -32,4 +33,13 @@ cc_library { 
        ],

        cfi: true,

    },



    // enumerate the stable interface

// this would mean nobody can use the C++ interface. have to rework some things.

//  stubs: {

//      symbol_file: "libmediametrics.map.txt",

//      versions: [

//          "1" ,

//      ]

//  },

}

media/libmediametrics/MediaAnalyticsItem.cpp

+21 −0
Original line number Diff line number Diff line
@@ -487,6 +487,18 @@ bool MediaAnalyticsItem::getCString(MediaAnalyticsItem::Attr name, char **value) 
    return true;

}



bool MediaAnalyticsItem::getString(MediaAnalyticsItem::Attr name, std::string *value) {

    Prop *prop = findProp(name);

    if (prop == NULL || prop->mType != kTypeCString) {

        return false;

    }

    if (value != NULL) {

        // std::string makes a copy for us

        *value = prop->u.CStringValue;

    }

    return true;

}



// remove indicated keys and their values

// return value is # keys removed

int32_t MediaAnalyticsItem::filter(int n, MediaAnalyticsItem::Attr attrs[]) {
@@ -726,6 +738,15 @@ int32_t MediaAnalyticsItem::writeToParcel(Parcel *data) { 
}





const char *MediaAnalyticsItem::toCString() {

   return toCString(PROTO_LAST);

}



const char * MediaAnalyticsItem::toCString(int version) {

    std::string val = toString(version);

    return strdup(val.c_str());

}



std::string MediaAnalyticsItem::toString() {

   return toString(PROTO_LAST);

}

media/libmediametrics/MediaMetrics.cpp

0 → 100644
+204 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "MediaMetrics"



#include <inttypes.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>



#include <media/MediaAnalyticsItem.h>

#include <media/MediaMetrics.h>



//

// provide a C-ish interface that is easier to stabilize than the existing C++

// interface

//

// ALL functions returning a char * give responsibility for the allocated buffer

// to the caller. The caller is responsible to call free() on that pointer.

//



// manage the overall record

mediametrics_handle_t mediametrics_create(mediametricskey_t key) {

    android::MediaAnalyticsItem *item = new android::MediaAnalyticsItem(key);

    return (mediametrics_handle_t) item;

}



void mediametrics_delete(mediametrics_handle_t handle) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) return;

    delete item;

}



mediametricskey_t mediametrics_getKey(mediametrics_handle_t handle) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) return NULL;

    return strdup(item->getKey().c_str());

}



// nuplayer, et al use it when acting as proxies

void mediametrics_setUid(mediametrics_handle_t handle, uid_t uid) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item != NULL) item->setUid(uid);

}



// set attributes

//



void mediametrics_setInt32(mediametrics_handle_t handle, attr_t attr,

                                int32_t value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item != NULL) item->setInt32(attr, value);

}



void mediametrics_setInt64(mediametrics_handle_t handle, attr_t attr,

                                int64_t value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item != NULL) item->setInt64(attr, value);

}



void mediametrics_setDouble(mediametrics_handle_t handle, attr_t attr,

                                 double value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item != NULL) item->setDouble(attr, value);

}



void mediametrics_setRate(mediametrics_handle_t handle, attr_t attr,

                               int64_t count, int64_t duration) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item != NULL) item->setRate(attr, count, duration);

}



void mediametrics_setCString(mediametrics_handle_t handle, attr_t attr,

                                 const char *value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item != NULL) item->setCString(attr, value);

}



// fused get/add/set; if attr wasn't there, it's a simple set.

//



void mediametrics_addInt32(mediametrics_handle_t handle, attr_t attr,

                                int32_t value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item != NULL) item->addInt32(attr, value);

}



void mediametrics_addInt64(mediametrics_handle_t handle, attr_t attr,

                                int64_t value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item != NULL) item->addInt64(attr, value);

}



void mediametrics_addDouble(mediametrics_handle_t handle, attr_t attr,

                                 double value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item != NULL) item->addDouble(attr, value);

}



void mediametrics_addRate(mediametrics_handle_t handle, attr_t attr,

                               int64_t count, int64_t duration) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item != NULL) item->addRate(attr, count, duration);

}



// find & extract values

// return indicates whether attr exists (and thus whether value filled in)

// NULL parameter value suppresses storage of value.

//



bool mediametrics_getInt32(mediametrics_handle_t handle, attr_t attr,

                                int32_t * value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) return false;

    return item->getInt32(attr, value);

}



bool mediametrics_getInt64(mediametrics_handle_t handle, attr_t attr,

                                int64_t * value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) return false;

    return item->getInt64(attr, value);

}



bool mediametrics_getDouble(mediametrics_handle_t handle, attr_t attr,

                                 double *value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) return false;

    return item->getDouble(attr, value);

}



bool mediametrics_getRate(mediametrics_handle_t handle, attr_t attr,

                               int64_t * count, int64_t * duration, double *rate) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) return false;

    return item->getRate(attr, count, duration, rate);

}



// NB: caller owns the string that comes back, is responsible for freeing it

bool mediametrics_getCString(mediametrics_handle_t handle, attr_t attr,

                                 char **value) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) return false;



    return item->getCString(attr, value);

}



// to release strings returned via getCString()

void mediametrics_freeCString(char *value) {

    free(value);

}



bool mediametrics_selfRecord(mediametrics_handle_t handle) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) return false;

    return item->selfrecord();

}





const char *mediametrics_readable(mediametrics_handle_t handle) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) return "";

    return item->toCString();

}



int32_t mediametrics_count(mediametrics_handle_t handle) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) return 0;

    return item->count();

}



bool mediametrics_isEnabled() {

    // static, so doesn't need an instance

    return android::MediaAnalyticsItem::isEnabled();

}



#if 0

// do not expose this as is.

// need to revisit (or redefine) how the android::Parcel parameter is handled

// so that it meets the stable-API criteria for updateable components.

//

int32_t mediametrics_writeToParcel(mediametrics_handle_t handle, android::Parcel *parcel) {

    android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;

    if (item == NULL) {

        return -1;

    }

    return item->writeToParcel(parcel);

}

#endif

media/libmediametrics/include/MediaAnalyticsItem.h

+3 −0
Original line number Diff line number Diff line
@@ -134,6 +134,7 @@ class MediaAnalyticsItem { 
        bool getRate(Attr, int64_t *count, int64_t *duration, double *rate);

        // Caller owns the returned string

        bool getCString(Attr, char **value);

        bool getString(Attr, std::string *value);



        // parameter indicates whether to close any existing open

        // record with same key before establishing a new record
@@ -176,6 +177,8 @@ class MediaAnalyticsItem { 


        std::string toString();

        std::string toString(int version);

        const char *toCString();

        const char *toCString(int version);



        // are we collecting analytics data

        static bool isEnabled();